Aes/entity tests

Ok, so please bear with me, this may seem strange and I'm still unsure about this. Maybe you can help me explore this issue a bit further.

First, you wrote above "Habits can be public or private.", then you added this scenario and the one below (`Creating a private habit`). This is ok, but at the same time it seems redundant. So I'd remove the paragraph from the habit description.

Second, I think there are 2 things that can be tested here: 1) that a habit can be set to either private or public, but not to anything else, and 2) what the behavior of the system towards public and private habits. I'd say `1` can be seen as an entity test but `2` can't. I also say *can* be seen, be cause it can also be seen as a behavior test (say, if you write a scenario that tests whether a user can mark a scenario private or public using the UI). So let me address each of these in turn:

If we consider `1` as an entity test, I'd probably write something like this:

```cucumber
Scenario: visibility

  A habit's visibility determines whether the habit can be shared by many users
  or specific to the user that created it.

  See also habit_visibility.feature

  * A habit can be private
  * A habit can be public
  * A habit can't have any other visibility
  * A habit's visibility must be set when the habit is created
```

Yes, `*` is a valid step marker. For example, cucumber will generate the following step, given `* A habit can be private`:

```ruby
Given(/^A habit can be private$/) do
  pending
end
```

etc. In this example I put the entity test in `habit.feature` and would now write the behavior tests in, say, `habit_visibility.feature`. These would include testing that, when a user creates a public habit (using the UI) then the UI would be made public, that other users would be able to be associated to that habit, etc.

Another option is to move the scenario above into `habit_visibility.feature` (making it the first scenario). Only the entity test would run when you run `cucumber --tag @entity`, so where it is makes no difference. It's only important from a readability perspective.

Another option is to not have an entity test for this (i.e., consider `1` a behavioral test). So instead you'd have another scenario:

```cucumber
Scenario: ???

  When a user is about to create a habit
  Then they should see they can pick one of the following visibilities:
    | public  |
    | private |

Scenario: ???

  When a user tries to create a habit with the same name as another public habit
  Then the user should be added to the previously existing habit
  And the system should not create any new habit
```

The final option is to have the entity test and the behavioral test, since they still test different things. It's up to you to decide which tests make the most sense, given time constraints and relative importance of the functionality you're working on.

I hope this helps. Any comments?