def test_patch_missing_attribute(self): fixture = MonkeyPatch( 'fixtures.tests._fixtures.test_monkeypatch.new_attr', True) self.assertFalse('new_attr' in globals()) fixture.setUp() try: self.assertEqual(True, new_attr) finally: fixture.cleanUp() self.assertFalse('new_attr' in globals())
def test_patch_and_restore(self): fixture = MonkeyPatch( 'fixtures.tests._fixtures.test_monkeypatch.reference', 45) self.assertEqual(23, reference) fixture.setUp() try: self.assertEqual(45, reference) finally: fixture.cleanUp() self.assertEqual(23, reference)
def test_delete_missing_attribute(self): fixture = MonkeyPatch( 'fixtures.tests._fixtures.test_monkeypatch.new_attr', MonkeyPatch.delete) self.assertFalse('new_attr' in globals()) fixture.setUp() try: self.assertFalse('new_attr' in globals()) finally: fixture.cleanUp() self.assertFalse('new_attr' in globals())
def test_delete_existing_attribute(self): fixture = MonkeyPatch( 'fixtures.tests._fixtures.test_monkeypatch.reference', MonkeyPatch.delete) self.assertEqual(23, reference) fixture.setUp() try: self.assertFalse('reference' in globals()) finally: fixture.cleanUp() self.assertEqual(23, reference)
def test_stat_shares_mutable(self, storage_index, secrets, test_and_write_vectors_for_shares, clock): """ Size and lease information about mutable shares can be retrieved from a storage server. """ # Hypothesis causes our storage server to be used many times. Clean # up between iterations. cleanup_storage_server(self.anonymous_storage_server) # anonymous_storage_server uses time.time(), unfortunately. And # useFixture does not interact very well with Hypothesis. patch = MonkeyPatch("time.time", clock.seconds) try: patch.setUp() # Create a share we can toy with. wrote, read = extract_result( self.client.slot_testv_and_readv_and_writev( storage_index, secrets=secrets, tw_vectors={ k: v.for_call() for (k, v) in test_and_write_vectors_for_shares.items() }, r_vector=[], ), ) finally: patch.cleanUp() self.assertThat( wrote, Equals(True), u"Server rejected a write to a new mutable slot", ) stats = extract_result(self.client.stat_shares([storage_index]), ) expected = [{ sharenum: ShareStat( size=get_implied_data_length( vectors.write_vector, vectors.new_length, ), lease_expiration=int(clock.seconds() + LEASE_INTERVAL), ) for (sharenum, vectors) in test_and_write_vectors_for_shares.items() }] self.assertThat( stats, Equals(expected), )
def _stat_shares_immutable_test(self, storage_index, sharenum, size, clock, leases, write_shares): # Hypothesis causes our storage server to be used many times. Clean # up between iterations. cleanup_storage_server(self.anonymous_storage_server) # anonymous_storage_server uses time.time(), unfortunately. And # useFixture does not interact very well with Hypothesis. patch = MonkeyPatch("time.time", clock.seconds) try: patch.setUp() # Create a share we can toy with. write_shares( self.anonymous_storage_server, storage_index, {sharenum}, size, canary=self.canary, ) # Perhaps put some more leases on it. Leases might impact our # ability to determine share data size. for renew_secret in leases: self.anonymous_storage_server.remote_add_lease( storage_index, renew_secret, b"", ) finally: patch.cleanUp() stats = extract_result(self.client.stat_shares([storage_index]), ) expected = [{ sharenum: ShareStat( size=size, lease_expiration=int(clock.seconds() + LEASE_INTERVAL), ), }] self.assertThat( stats, Equals(expected), )
def test_mutable_rewrite_renews_expired_lease( self, storage_index, clock, sharenum, size, write_enabler, renew_secret, cancel_secret, test_and_write_vectors_for_shares, ): """ When mutable share data with an expired lease is rewritten using *slot_testv_and_readv_and_writev* a new lease is paid for and granted. """ # Hypothesis causes our storage server to be used many times. Clean # up between iterations. cleanup_storage_server(self.anonymous_storage_server) # Make the client and server use our clock. self.server._clock = clock self.client._clock = clock secrets = (write_enabler, renew_secret, cancel_secret) def write(): return self.client.slot_testv_and_readv_and_writev( storage_index, secrets=secrets, tw_vectors={ k: v.for_call() for (k, v) in test_and_write_vectors_for_shares.items() }, r_vector=[], ) # anonymous_storage_server uses time.time() to assign leases, # unfortunately. patch = MonkeyPatch("time.time", clock.seconds) try: patch.setUp() # Create a share we can toy with. self.assertThat(write(), is_successful_write()) # Advance time by more than a lease period so the lease is no # longer valid. clock.advance(self.server.LEASE_PERIOD.total_seconds() + 1) self.assertThat(write(), is_successful_write()) finally: patch.cleanUp() # Not only should the write above succeed but the lease should now be # marked as expiring one additional lease period into the future. self.assertThat( self.server.remote_stat_shares([storage_index]), Equals([{ num: ShareStat( size=get_implied_data_length( test_and_write_vectors_for_shares[num].write_vector, test_and_write_vectors_for_shares[num].new_length, ), lease_expiration=int( clock.seconds() + self.server.LEASE_PERIOD.total_seconds()), ) for num in test_and_write_vectors_for_shares }]), )