Python models.Switch类代码示例

    def test_switch_state_can_be_changed(self):
        switch = Switch("foo")
        old_state = switch.state

        switch.state = Switch.states.GLOBAL
        eq_(switch.state, Switch.states.GLOBAL)
        ok_(old_state is not switch.state)

    def test_can_register_signals_and_get_notified(self):
        signals.switch_registered.connect(self.callback.switch_added)
        signals.switch_unregistered.connect(self.callback.switch_removed)
        signals.switch_updated.connect(self.callback.switch_updated)

        eq_(self.callback.register_calls, [])
        eq_(self.callback.unregister_calls, [])
        eq_(self.callback.update_calls, [])

        switch = Switch("foo")

        self.manager.register(switch)
        eq_(self.callback.register_calls, [switch])

        self.manager.unregister(switch.name)
        eq_(self.callback.unregister_calls, [switch])

        self.manager.register(switch)
        eq_(self.callback.register_calls, [switch, switch])

        switch.state = Switch.states.GLOBAL
        self.manager.update(switch)

        change = self.callback.update_calls[0]
        eq_(change[0], switch)
        changes = change[1]
        eq_(changes["state"], dict(current=Switch.states.GLOBAL, previous=Switch.states.DISABLED))

    def test_retrieved_switches_can_be_updated(self):
        switch = Switch("foo")
        self.manager.register(switch)

        self.assertEquals(self.manager.switch("foo").name, "foo")

        switch.state = Switch.states.GLOBAL
        switch.save()

        self.assertEquals(self.manager.switch("foo").state, Switch.states.GLOBAL)

    def test_switches_are_still_equal_with_different_managers(self):
        a = Switch("a")
        b = Switch("a")

        eq_(a, b)

        a.manager = "foo"
        b.manager = "bar"

        eq_(a, b)

    def add_switch(self, name, condition=None, *conditions, **kwargs):
        switch = Switch(name, compounded=kwargs.get("compounded", False))
        switch.state = kwargs.get("state", Switch.states.SELECTIVE)
        conditions = list(conditions)

        if condition:
            conditions.append(condition)

        [switch.conditions.append(c) for c in conditions]
        kwargs.get("manager", self.manager).register(switch)
        return switch

    def test_legacy_unpickle(self):
        d = EncodingDict()

        parent = Switch('a')
        switch = Switch('a:b')

        children = [
            Switch('a:b:c'),
            Switch('a:b:d'),
        ]

        [setattr(child, 'parent', switch) for child in children]

        switch.children = children
        switch.parent = parent

        decoded_switch = d._decode(d._encode(switch))
        self.assertEquals(decoded_switch.name, switch.name)
        self.assertEquals(decoded_switch.parent, switch.parent.name)
        self.assertListEqual([child.name for child in children], decoded_switch.children)

    def test_retrieved_switches_can_be_updated(self):
        switch = Switch('foo')
        self.manager.register(switch)

        switch.name = 'steve'
        switch.save()

        self.assertRaises(ValueError, self.manager.switch, 'foo')
        self.assertEquals(self.manager.switch('steve').name, 'steve')

        switch.name = 'bob'
        switch.state = Switch.states.GLOBAL
        switch.save()

        self.assertEquals(self.manager.switch('bob').name, 'bob')
        self.assertEquals(
            self.manager.switch('bob').state,
            Switch.states.GLOBAL
        )
        self.assertRaises(ValueError, self.manager.switch, 'steve')

    def test_can_register_signals_and_get_notified(self):
        signals.switch_registered.connect(self.callback.switch_added)
        signals.switch_unregistered.connect(self.callback.switch_removed)
        signals.switch_updated.connect(self.callback.switch_updated)

        eq_(self.callback.register_calls, [])
        eq_(self.callback.unregister_calls, [])
        eq_(self.callback.update_calls, [])

        switch = Switch('foo')

        self.manager.register(switch)
        eq_(self.callback.register_calls, [switch])

        self.manager.unregister(switch.name)
        eq_(self.callback.unregister_calls, [switch])

        self.manager.register(switch)
        eq_(self.callback.register_calls, [switch, switch])

        switch.name = 'a new name'
        switch.state = Switch.states.GLOBAL
        self.manager.update(switch)

        change = self.callback.update_calls[0]
        eq_(change[0], switch)
        changes = change[1]
        eq_(changes['name'], dict(current='a new name', previous='foo'))
        eq_(changes['state'], dict(current=Switch.states.GLOBAL, previous=Switch.states.DISABLED))

        switch.name = 'from save() call'
        switch.save()

        change = self.callback.update_calls[1]
        eq_(change[0], switch)
        changes = change[1]
        eq_(changes['name'], dict(current='from save() call', previous='a new name'))

 def build_and_register_switch(self, name, enabled_for=False):
     switch = Switch(name)
     switch.enabled_for = mock.Mock(return_value=enabled_for)
     self.manager.register(switch)
     return switch

 def test_switch_name_is_immutable(self):
     switch = Switch("foo")
     with self.assertRaises(AttributeError):
         switch.name = "bar"

 def test_switch_enabed_for_skips_switch_active_signal_when_not_enabled(self, signal):
     switch = Switch("foo", state=Switch.states.DISABLED)
     eq_(switch.enabled_for("causing input"), False)
     eq_(signal.call.called, False)

 def test_switch_enabed_for_calls_switch_active_signal_when_enabled(self, signal):
     switch = Switch("foo", state=Switch.states.GLOBAL)
     ok_(switch.enabled_for("causing input"))
     signal.call.assert_called_once_with(switch, "causing input")

 def test_switch_enabed_for_calls_switch_checked_signal(self, signal):
     switch = Switch("foo")
     switch.enabled_for(True)
     signal.call.assert_called_once_with(switch)

 def test_switch_enabed_for_skips_switch_active_signal_when_not_enabled(self, signal):
     switch = Switch('foo', manager='manager', state=Switch.states.DISABLED)
     eq_(switch.enabled_for('causing input'), False)
     eq_(signal.call.called, False)

 def test_switch_enabed_for_calls_switch_active_signal_when_enabled(self, signal):
     switch = Switch('foo', manager='manager', state=Switch.states.GLOBAL)
     ok_(switch.enabled_for('causing input'))
     signal.call.assert_called_once_with(switch, 'causing input')