I can tell you how I did unstall when I started working again on this kata. I was thinking of “beats” as a mathematical binary relation. There is a lot of power in modelling problems with mathematics. And it’s not complicated mathematics. A book that explains a bit: http://www.usingz.com/text/online/index.html

a very simple and good solution.
I think we must analyse why we stalled at coding dojo, I think that could help us for the next similar meetings. We must question ourself how to arrive to a conclusion in a simple and a quick-time way still allowing potentially all participants to exploit/declare their ideas/design.

Thx.

the test of a design is how easy it is to adapt the design to new requirements. Suppose you wanted to extend your program to handle Rock-scissors-paper-spock-lizard? Suppose you needed to support both so that the players can decide which set of rules to use before each game?

I’m intrigued by the OCP Dojo rules, but I’m not sure I grasped them entirely.
I’ve tried this kata in Python and I was a bit disappointed by how trivial the solution was. This is my final version:

class Item(object):
def beats(self, other):
return other.__class__.__name__ in self._beats

class Rock(Item):
_beats = [‘Scissors’]

class Scissors(Item):
_beats = [‘Paper’]

class Paper(Item):
_beats = [‘Rock’]

class Beats_TestCase(unittest.TestCase):
def test_rock_beats_scissors(self):
self.assertTrue(Rock().beats(Scissors()))

def test_scissors_does_not_beat_rock(self):
self.assertTrue(not Scissors().beats(Rock()))

def test_rock_does_not_beat_rock(self):
self.assertTrue(not Rock().beats(Rock()))

def test_scissors_beats_paper(self):
self.assertTrue(Scissors().beats(Paper()))

def test_paper_beats_rock(self):
self.assertTrue(Paper().beats(Rock()))

As you can see, it’s a typical case of unit-testing that 2+2 equals 4. It’s stating the obvious. In this case the implementation is so trivial that it equals the behavior. So it’s basically like testing the implementation, which is wrong in general.

The point is, I don’t see how I contravened the OCP Dojo rules. Is it maybe because my “factories” are the object constructors? Should I have used an actual factory method instead?

I follow your post and I like your considerations, but I feel like I won’t be able to come to this kind of interesting reasonings if I fall into the 2+2 trap so easily.

Cheers,
Stefano