It could update the cache associated with the already provided ENTITLEMENT_STATUS_CACHE.

I'm not sure what the best idiom for these cases is, and I think current code already does a mix of various approaches:

 * create a stub and assign to fixture instances
```
class Fixture(object):
    def setUp(self):
         self.blah = StubBlah()
          inj.provide(inj.BLAH, self.blah)
```
```
class Test(Fixture):
   def test_foo(self):
         self.blah = SomeOtherBlah()
         <...>
```

 * provide instance in fixture, provide custom in tests

```
class Fixture(object):
    def setUp(self):
          inj.provide(inj.BLAH, StubBlah())
```

```
class Test(Fixture):
     def test_blip(self):
          inj.provide(inj.BLAH, SomeMockBlah()
          <...>
```

 * provide a stub/mock with a fixture instance var and re-require
```
class Fixture(object):
    def setUp(sefl):
          self.stub_blah = StubBlah()
          inj.provide(inj.BLAH, self.stub_blah)
```

```
class Test(Fixture):
      def test_blip(self):
           self.stub_blah = SomeNewStubOrMockBlah()
            # get new/update BLAH that uses self.stub_blah
           blah = inj.require(inj.BLAH)
           <...>
```

I do want to move fixture tests to at least have some sort of namespace object for it's instance variables. ie, something like:

```
class FixtureThings(object):
     pass

class Fixture(unittest.UnitTest):
      def setUp(self):
              self.fixture = FixtureThings()
              self.fixture.stub_blah = StubBlah()
              inj.provide(inj.BLAH, self.fixture.stub_blah)
```

So that tests are less confusing

```
class Test(Fixture):
      def test_blip(self):
             self.fixture.stub_blah.thingamajig = 5
             <...>
```

But that also introduces more places to mock/patch (now you could replace self.fixture entirely, etc).