Пример #1
0
    def _test_repo(self, service, host, port):

        service_key = service.GetServiceKey()

        # news

        news = 'this is the news'

        service.Request(HC.POST, 'news', {'news': news})

        written = HydrusGlobals.test_controller.GetWrite('news')

        [(args, kwargs)] = written

        (written_service_key, written_news) = args

        self.assertEqual(news, written_news)

        # num_petitions

        num_petitions = 23

        HydrusGlobals.test_controller.SetRead('num_petitions', num_petitions)

        response = service.Request(HC.GET, 'num_petitions')

        self.assertEqual(response['num_petitions'], num_petitions)

        # petition

        action = HC.CONTENT_UPDATE_PETITION
        account_identifier = HydrusData.AccountIdentifier(
            account_key=HydrusData.GenerateKey())
        reason = 'it sucks'
        contents = [
            HydrusData.Content(HC.CONTENT_TYPE_FILES,
                               [HydrusData.GenerateKey() for i in range(10)])
        ]

        petition = HydrusData.ServerToClientPetition(
            action=action,
            petitioner_account_identifier=account_identifier,
            reason=reason,
            contents=contents)

        HydrusGlobals.test_controller.SetRead('petition', petition)

        response = service.Request(HC.GET, 'petition')

        self.assertEqual(type(response), HydrusData.ServerToClientPetition)

        # update

        begin = 100
        subindex_count = 5

        update = HydrusData.ServerToClientServiceUpdatePackage()
        update.SetBeginEnd(begin, begin + HC.UPDATE_DURATION - 1)
        update.SetSubindexCount(subindex_count)

        path = ServerFiles.GetExpectedServiceUpdatePackagePath(
            service_key, begin)

        with open(path, 'wb') as f:
            f.write(update.DumpToNetworkString())

        response = service.Request(HC.GET, 'service_update_package',
                                   {'begin': begin})

        self.assertEqual(response.GetBegin(), update.GetBegin())

        try:
            os.remove(path)
        except:
            pass

        subindex = 2
        num_hashes = 12
        tag = 'series:blah'
        hash_ids_to_hashes = {i: HydrusData.GenerateKey() for i in range(12)}
        rows = [(tag, [i for i in range(num_hashes)])]

        update = HydrusData.ServerToClientContentUpdatePackage()
        update.AddContentData(HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_UPDATE_ADD,
                              rows, hash_ids_to_hashes)

        path = ServerFiles.GetExpectedContentUpdatePackagePath(
            service_key, begin, subindex)

        with open(path, 'wb') as f:
            f.write(update.DumpToNetworkString())

        response = service.Request(HC.GET, 'content_update_package', {
            'begin': begin,
            'subindex': subindex
        })

        self.assertEqual(response.GetNumContentUpdates(),
                         update.GetNumContentUpdates())

        try:
            os.remove(path)
        except:
            pass

        update = HydrusData.ClientToServerContentUpdatePackage(
            {}, hash_ids_to_hashes)

        service.Request(HC.POST, 'content_update_package', {'update': update})

        written = HydrusGlobals.test_controller.GetWrite('update')

        [(args, kwargs)] = written

        (written_service_key, written_account, written_update) = args

        self.assertEqual(update.GetHashes(), written_update.GetHashes())
Пример #2
0
    def _test_repo(self, service):

        service_key = service.GetServiceKey()

        # num_petitions

        num_petitions = [
            (HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_STATUS_PETITIONED, 23),
            (HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PENDING, 0)
        ]

        HydrusGlobals.test_controller.SetRead('num_petitions', num_petitions)

        response = service.Request(HC.GET, 'num_petitions')

        self.assertEqual(response['num_petitions'], num_petitions)

        # petition

        action = HC.CONTENT_UPDATE_PETITION
        petitioner_account = HydrusNetwork.Account.GenerateUnknownAccount()
        reason = 'it sucks'
        contents = [
            HydrusNetwork.Content(
                HC.CONTENT_TYPE_FILES,
                [HydrusData.GenerateKey() for i in range(10)])
        ]

        petition = HydrusNetwork.Petition(action, petitioner_account, reason,
                                          contents)

        HydrusGlobals.test_controller.SetRead('petition', petition)

        response = service.Request(HC.GET, 'petition')

        self.assertEqual(response['petition'].GetSerialisableTuple(),
                         petition.GetSerialisableTuple())

        # definitions

        definitions_update = HydrusNetwork.DefinitionsUpdate()

        if i in range(100, 200):

            definitions_update.AddRow(
                (HC.DEFINITIONS_TYPE_TAGS, i, 'series:test ' + str(i)))
            definitions_update.AddRow((HC.DEFINITIONS_TYPE_HASHES, i + 500,
                                       HydrusData.GenerateKey()))

        definitions_update_network_string = definitions_update.DumpToNetworkString(
        )

        definitions_update_hash = hashlib.sha256(
            definitions_update_network_string).digest()

        path = ServerFiles.GetExpectedFilePath(definitions_update_hash)

        with open(path, 'wb') as f:
            f.write(definitions_update_network_string)

        response = service.Request(HC.GET, 'update',
                                   {'update_hash': definitions_update_hash})

        try:
            os.remove(path)
        except:
            pass

        self.assertEqual(response, definitions_update_network_string)

        # content

        rows = [(random.randint(100, 1000),
                 [random.randint(100, 1000) for i in range(50)])
                for j in range(20)]

        content_update = HydrusNetwork.ContentUpdate()

        for row in rows:

            content_update.AddRow(
                (HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_UPDATE_ADD, row))

        content_update_network_string = content_update.DumpToNetworkString()

        content_update_hash = hashlib.sha256(
            content_update_network_string).digest()

        path = ServerFiles.GetExpectedFilePath(content_update_hash)

        with open(path, 'wb') as f:
            f.write(content_update_network_string)

        response = service.Request(HC.GET, 'update',
                                   {'update_hash': content_update_hash})

        try:
            os.remove(path)
        except:
            pass

        self.assertEqual(response, content_update_network_string)

        # metadata

        metadata = HydrusNetwork.Metadata()

        metadata.AppendUpdate([definitions_update_hash, content_update_hash],
                              HydrusData.GetNow() - 101000,
                              HydrusData.GetNow() - 1000,
                              HydrusData.GetNow() + 100000)

        service._metadata = metadata

        response = service.Request(HC.GET, 'metadata_slice', {'since': 0})

        self.assertEqual(response['metadata_slice'].GetSerialisableTuple(),
                         metadata.GetSerialisableTuple())

        # post content

        update = HydrusData.ClientToServerContentUpdatePackage(
            {}, hash_ids_to_hashes)

        service.Request(HC.POST, 'content_update_package', {'update': update})

        written = HydrusGlobals.test_controller.GetWrite('update')

        [(args, kwargs)] = written

        (written_service_key, written_account, written_update) = args

        self.assertEqual(update.GetHashes(), written_update.GetHashes())