def test_does_not_create_thing_if_no_files_found(
            self, get_files_to_process_from_titelive_ftp, app):
        # mock
        files_list = list()
        get_files_to_process_from_titelive_ftp.return_value = files_list

        # given
        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')
        PcObject.save(venue)

        provider_test(app,
                      TiteLiveThings,
                      None,
                      checkedObjects=0,
                      createdObjects=0,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=0)
    def test_does_not_create_thing_if_too_few_elements_in_data_line(
            self, get_lines_from_thing_file,
            get_files_to_process_from_titelive_ftp, app):
        # mock
        files_list = list()
        files_list.append('Quotidien30.tit')

        get_files_to_process_from_titelive_ftp.return_value = files_list

        data_line = "9782895026310"

        get_lines_from_thing_file.return_value = iter([data_line])

        # given

        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')
        PcObject.save(venue)

        provider_test(app,
                      TiteLiveThings,
                      None,
                      checkedObjects=1,
                      createdObjects=0,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=0)
    def test_create_multiple_things_with_sandboxes_data(
            self, get_lines_from_thing_file,
            get_files_to_process_from_titelive_ftp, app):
        # mock
        files = get_ordered_thing_files_from_sandbox_files()
        get_files_to_process_from_titelive_ftp.return_value = files

        files_content = []
        for file in files:
            content = get_lines_from_thing_file_sandboxes(file)
            files_content.append(content)

        get_lines_from_thing_file.side_effect = files_content

        # given
        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')
        PcObject.save(venue)

        provider_test(app,
                      TiteLiveThings,
                      None,
                      checkedObjects=422,
                      createdObjects=340,
                      updatedObjects=16,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=340)
def test_titelive_stock_provider_create_nothing_if_siret_is_not_in_titelive_database(app):
    # given
    offerer = create_offerer(siren='987654321')
    venue = create_venue(offerer, name='Librairie Titelive', siret='12345678912345')
    PcObject.save(venue)

    tite_live_things_provider = get_provider_by_local_class('TiteLiveThings')
    venue_provider = VenueProvider()
    venue_provider.venue = venue
    venue_provider.provider = tite_live_things_provider
    venue_provider.isActive = True
    venue_provider.venueIdAtOfferProvider = '12345678912345'
    PcObject.save(venue_provider)

    product = create_product_with_thing_type(id_at_providers='0002730757438')
    offer = create_offer_with_thing_product(venue=venue, product=product)
    PcObject.save(product, offer)

    # When / Then
    provider_test(app,
                  TiteLiveStocks,
                  venue_provider,
                  checkedObjects=0,
                  createdObjects=0,
                  updatedObjects=0,
                  erroredObjects=0,
                  checkedThumbs=0,
                  createdThumbs=0,
                  updatedThumbs=0,
                  erroredThumbs=0,
                  Stock=0
                  )
    def test_compute_first_thumb_dominant_color_even_if_not_first_file(self,
                                                                       get_thumbs_zip_file_from_ftp,
                                                                       get_ordered_thumbs_zip_files,
                                                                       app):
        # given
        product1 = create_product_with_thing_type(id_at_providers='9780847858903', thumb_count=0)
        product2 = create_product_with_thing_type(id_at_providers='9782016261903', thumb_count=0)
        PcObject.save(product1, product2)

        # mock TiteliveThingThumb
        files = get_ordered_zip_thumbs_files_from_sandbox_files()
        get_ordered_thumbs_zip_files.return_value = files

        zip_files = []
        for file in files:
            zip_file = get_zip_file_from_sandbox(file)
            zip_files.append(zip_file)
        get_thumbs_zip_file_from_ftp.side_effect = zip_files

        # Import thumbs for existing things
        provider_test(app,
                      TiteLiveThingThumbs,
                      None,
                      checkedObjects=2,
                      createdObjects=0,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=2,
                      createdThumbs=5,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=0
                      )
def test_titelive_stock_provider_create_1_stock_and_1_offer(get_data, app):
    # given
    get_data.return_value = {
        'total': 'null',
        'limit': 5000,
        'stocks': [
            {
                "ref": "0002730757438",
                "available": 10,
                "price": 4500,
                "validUntil": "2019-10-31T15:10:27Z"
            }
        ]
    }

    offerer = create_offerer(siren='775671464')
    venue = create_venue(offerer, name='Librairie Titelive', siret='77567146400110')
    PcObject.save(venue)

    tite_live_things_provider = get_provider_by_local_class('TiteLiveThings')
    venue_provider = VenueProvider()
    venue_provider.venue = venue
    venue_provider.provider = tite_live_things_provider
    venue_provider.isActive = True
    venue_provider.venueIdAtOfferProvider = '77567146400110'
    PcObject.save(venue_provider)

    product = create_product_with_thing_type(id_at_providers='0002730757438')
    PcObject.save(product)

    # When / Then
    provider_test(app,
                  TiteLiveStocks,
                  venue_provider,
                  checkedObjects=2,
                  createdObjects=2,
                  updatedObjects=0,
                  erroredObjects=0,
                  checkedThumbs=0,
                  createdThumbs=0,
                  updatedThumbs=0,
                  erroredThumbs=0,
                  Stock=1,
                  Offer=1
                  )

    offer = Offer.query.one()
    assert offer.type == product.type
    assert offer.name == product.name
    assert offer.description == product.description
    assert offer.venue is not None
    assert offer.bookingEmail is None
    assert offer.extraData == product.extraData
    stock = Stock.query.one()
    assert stock.bookingLimitDatetime is None
    assert stock.available == 10
    assert stock.price == 45
def test_titelive_stock_provider_create_2_stock_and_2_offer_even_if_existing_offer_on_same_product(get_data, app):
    # given
    get_data.return_value = {
        'total': 'null',
        'limit': 5000,
        'stocks': [
            {
                "ref": "0002730757438",
                "available": 10,
                "price": 4500,
                "validUntil": "2019-10-31T15:10:27Z"
            },
            {
                "ref": "0002736409898",
                "available": 2,
                "price": 100,
                "validUntil": "2019-10-31T15:10:27Z"
            }
        ]
    }

    offerer = create_offerer(siren='987654321')
    venue = create_venue(offerer, name='Librairie Titelive', siret='77567146400110')
    PcObject.save(venue)

    tite_live_things_provider = get_provider_by_local_class('TiteLiveThings')
    venue_provider = VenueProvider()
    venue_provider.venue = venue
    venue_provider.provider = tite_live_things_provider
    venue_provider.isActive = True
    venue_provider.venueIdAtOfferProvider = '77567146400110'
    PcObject.save(venue_provider)

    thing_1 = create_product_with_thing_type(id_at_providers='0002730757438')
    thing_2 = create_product_with_thing_type(id_at_providers='0002736409898')
    offer = create_offer_with_thing_product(venue=venue, product=thing_1, id_at_providers="not_titelive")
    PcObject.save(thing_1, offer, thing_2)

    # When / Then
    provider_test(app,
                  TiteLiveStocks,
                  venue_provider,
                  checkedObjects=4,
                  createdObjects=4,
                  updatedObjects=0,
                  erroredObjects=0,
                  checkedThumbs=0,
                  createdThumbs=0,
                  updatedThumbs=0,
                  erroredThumbs=0,
                  Stock=2,
                  Offer=2
                  )
Esempio n. 8
0
    def test_updates_bank_information_when_existing_bank_information_with_same_id_at_provider(self,
                                                                                              find_latest_sync_end_event,
                                                                                              get_application_details,
                                                                                              get_all_application_ids_for_procedure,
                                                                                              environment,
                                                                                              app):
        # given
        offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID)
        venue = create_venue(offerer=offerer, idx=self.VENUE_ID)
        bank_information = create_bank_information(
            application_id=self.APPLICATION_ID,
            bic='PSSTFRPPLIL',
            iban="FR1420041010050500013M02606",
            offerer=offerer,
            venue=venue,
            id_at_providers=f"{self.OFFERER_ID}|{self.VENUE_ID}"
        )
        PcObject.save(venue, bank_information)
        last_provider_sync = LocalProviderEvent()
        last_provider_sync.date = datetime(2020, 1, 2)
        find_latest_sync_end_event.return_value = last_provider_sync
        get_all_application_ids_for_procedure.return_value = [self.APPLICATION_ID]
        NEW_IBAN = 'FR7630006000011234567890189'
        NEW_BIC = 'AGRIFRPP'
        get_application_details.return_value = _create_detail_response(
            self.APPLICATION_ID, self.OFFERER_ID, self.VENUE_ID, iban=NEW_IBAN, bic=NEW_BIC
        )

        # when
        provider_test(app,
                      VenueWithoutSIRETBankInformationProvider,
                      None,
                      checkedObjects=1,
                      createdObjects=0,
                      updatedObjects=1,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0)

        # then
        bank_information = BankInformation.query.all()
        assert len(bank_information) == 1

        bank_information = BankInformation.query.first()
        assert bank_information.iban == NEW_IBAN
        assert bank_information.bic == NEW_BIC
        assert bank_information.offererId == self.OFFERER_ID
        assert bank_information.venueId == self.VENUE_ID
def test_titelive_stock_provider_deactivate_offer_if_stock_available_equals_0(get_data, app):
    # given
    get_data.return_value = {
        'total': 'null',
        'limit': 5000,
        'stocks': [
            {
                "ref": "0002730757438",
                "available": 0,
                "price": 4500,
                "validUntil": "2019-10-31T15:10:27Z"
            }
        ]
    }

    offerer = create_offerer(siren='775671464')
    venue = create_venue(offerer, name='Librairie Titelive', siret='77567146400110')
    PcObject.save(venue)

    tite_live_things_provider = get_provider_by_local_class('TiteLiveThings')
    venue_provider = VenueProvider()
    venue_provider.venue = venue
    venue_provider.provider = tite_live_things_provider
    venue_provider.isActive = True
    venue_provider.venueIdAtOfferProvider = '77567146400110'
    PcObject.save(venue_provider)

    product = create_product_with_thing_type(id_at_providers='0002730757438')
    offer = create_offer_with_thing_product(venue, product=product, id_at_providers='0002730757438@77567146400110')
    stock = create_stock(offer=offer, id_at_providers='0002730757438@77567146400110')
    PcObject.save(product, offer, stock)

    # When / Then
    provider_test(app,
                  TiteLiveStocks,
                  venue_provider,
                  checkedObjects=2,
                  createdObjects=0,
                  updatedObjects=2,
                  erroredObjects=0,
                  checkedThumbs=0,
                  createdThumbs=0,
                  updatedThumbs=0,
                  erroredThumbs=0
                  )

    offer = Offer.query.one()
    assert offer.isActive is False
Esempio n. 10
0
    def test_open_agenda_events_creaet_data_from_sandboxe_file(
            self, get_data, app):
        # mock
        open_agenda_sandboxes_files = [1, 2]
        sandboxes_data = []
        for page in open_agenda_sandboxes_files:
            data_content = get_data_from_sandbox_files(page)
            sandboxes_data.append(data_content)

        get_data.side_effect = sandboxes_data

        # given
        offerer = create_offerer(siren='123456789')
        venue = create_venue(offerer,
                             name='Librairie OpenAgenda',
                             siret='12345678901231')
        PcObject.save(venue)
        venue_id = venue.id

        open_agenda_provider = get_provider_by_local_class('OpenAgendaEvents')
        venue_provider = VenueProvider()
        venue_provider.venueId = venue_id
        venue_provider.provider = open_agenda_provider
        venue_provider.isActive = True
        venue_provider.venueIdAtOfferProvider = '49050769'
        PcObject.save(venue_provider)
        venue_provider = VenueProvider.query \
            .filter_by(venueIdAtOfferProvider='49050769') \
            .one_or_none()
        provider_test(app,
                      OpenAgendaEvents,
                      venue_provider,
                      checkedObjects=18,
                      createdObjects=18,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=3,
                      createdThumbs=3,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Event=3,
                      EventOccurrence=12,
                      Offer=3,
                      Stock=0,
                      Venue=0,
                      Offerer=0)
Esempio n. 11
0
    def test_collect_application_details_for_each_application(self,
                                                              find_latest_sync_end_event,
                                                              get_application_details,
                                                              get_all_application_ids_for_procedure,
                                                              app):
        # given
        APPLICATION_ID_2 = 2
        last_provider_sync = LocalProviderEvent()
        last_provider_sync.date = datetime(2020, 1, 2)
        find_latest_sync_end_event.return_value = last_provider_sync
        get_all_application_ids_for_procedure.return_value = [self.APPLICATION_ID,
                                                                                     APPLICATION_ID_2]
        get_application_details.return_value = _create_detail_response(self.APPLICATION_ID, self.OFFERER_ID,
                                                                       self.VENUE_ID)

        PROCEDURE_ID_VENUE_WITHOUT_SIRET = '5636727'
        TOKEN = '4872'
        offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID)
        venue = create_venue(offerer=offerer, idx=self.VENUE_ID)
        PcObject.save(venue)

        # when
        with patch.dict(os.environ, {
            'DEMARCHES_SIMPLIFIEES_VENUE_WITHOUT_SIRET_PROCEDURE_ID': PROCEDURE_ID_VENUE_WITHOUT_SIRET,
            'DEMARCHES_SIMPLIFIEES_TOKEN': TOKEN
        }, clear=True):
            provider_test(app,
                          VenueWithoutSIRETBankInformationProvider,
                          None,
                          checkedObjects=0,
                          createdObjects=2,
                          updatedObjects=0,
                          erroredObjects=0,
                          checkedThumbs=0,
                          createdThumbs=0,
                          updatedThumbs=0,
                          erroredThumbs=0,
                          BankInformation=0)

        # then
        assert get_application_details.call_count == 2
        assert get_application_details.call_args_list == [
            call(self.APPLICATION_ID, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN),
            call(APPLICATION_ID_2, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN)
        ]
Esempio n. 12
0
    def test_create_bank_information_when_the_bank_information_does_not_exist(self,
                                                                              find_latest_sync_end_event,
                                                                              get_application_details,
                                                                              get_all_application_ids_for_procedure,
                                                                              environment,
                                                                              app):
        # given
        IBAN = 'FR7630006000011234567890189'
        BIC = 'BDFEFR2LCCB'
        offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID)
        venue = create_venue(offerer=offerer, idx=self.VENUE_ID)
        PcObject.save(venue)
        last_provider_sync = LocalProviderEvent()
        last_provider_sync.date = datetime(2020, 1, 2)
        find_latest_sync_end_event.return_value = last_provider_sync
        get_all_application_ids_for_procedure.return_value = [self.APPLICATION_ID]
        get_application_details.return_value = _create_detail_response(
            self.APPLICATION_ID, self.OFFERER_ID, self.VENUE_ID, iban=IBAN, bic=BIC
        )

        # when
        provider_test(app,
                      VenueWithoutSIRETBankInformationProvider,
                      None,
                      checkedObjects=1,
                      createdObjects=1,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      BankInformation=1)

        # then
        bank_information = BankInformation.query.first()
        assert bank_information.iban == IBAN
        assert bank_information.bic == BIC
        assert bank_information.venueId == self.VENUE_ID
    def test_does_not_create_thing_if_too_many_elements_in_data_line(
            self, get_lines_from_thing_file,
            get_files_to_process_from_titelive_ftp, app):
        # mock
        files_list = list()
        files_list.append('Quotidien30.tit')

        get_files_to_process_from_titelive_ftp.return_value = files_list

        data_line = "9782895026310" \
                    "~2895026319" \
                    "~nouvelles du Chili" \
                    "~" \
                    "~0203" \
                    "~1" \
                    "~" \
                    "~" \
                    "~" \
                    "~18,99" \
                    "~LES EDITIONS DE L'INSTANT MEME" \
                    "~EPAGINE" \
                    "~11/05/2011" \
                    "~LE" \
                    "~2" \
                    "~0" \
                    "~0,0" \
                    "~0,0" \
                    "~0,0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~Collectif" \
                    "~15/01/2013" \
                    "~02/03/2018" \
                    "~5,50" \
                    "~Littérature Hispano-Portugaise" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~1" \
                    "~3012420280013" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~0" \
                    "~" \
                    "~369" \
                    "~860" \
                    "~3694440" \
                    "~" \
                    "~Few Data" \
                    "~Some Test Data" \
                    "~Test Data" \
                    "~Other Test Data"
        get_lines_from_thing_file.return_value = iter([data_line])

        # given

        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')
        PcObject.save(venue)

        provider_test(app,
                      TiteLiveThings,
                      None,
                      checkedObjects=1,
                      createdObjects=0,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=0)
    def test_create_1_thing_from_one_data_line_in_one_file(
            self, get_lines_from_thing_file,
            get_files_to_process_from_titelive_ftp, app):
        # mock
        files_list = list()
        files_list.append('Quotidien30.tit')

        get_files_to_process_from_titelive_ftp.return_value = files_list

        data_line = "9782895026310" \
                    "~2895026319" \
                    "~nouvelles du Chili" \
                    "~" \
                    "~0203" \
                    "~1" \
                    "~" \
                    "~" \
                    "~" \
                    "~18,99" \
                    "~LES EDITIONS DE L'INSTANT MEME" \
                    "~EPAGINE" \
                    "~11/05/2011" \
                    "~BL" \
                    "~2" \
                    "~0" \
                    "~0,0" \
                    "~0,0" \
                    "~0,0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~Collectif" \
                    "~15/01/2013" \
                    "~02/03/2018" \
                    "~5,50" \
                    "~Littérature Hispano-Portugaise" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~1" \
                    "~3012420280013" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~0" \
                    "~" \
                    "~369" \
                    "~860" \
                    "~3694440" \
                    "~"
        get_lines_from_thing_file.return_value = iter([data_line])

        # given
        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')
        PcObject.save(venue)

        provider_test(app,
                      TiteLiveThings,
                      None,
                      checkedObjects=1,
                      createdObjects=1,
                      updatedObjects=0,
                      erroredObjects=0,
                      checkedThumbs=0,
                      createdThumbs=0,
                      updatedThumbs=0,
                      erroredThumbs=0,
                      Product=1)

        product = Product.query.one()
        assert product.extraData.get(
            'bookFormat') == BookFormat.BEAUX_LIVRES.value
        assert product.type == 'ThingType.LIVRE_EDITION'
    def test_update_1_thing_from_one_data_line_in_one_file(
            self, get_lines_from_thing_file,
            get_files_to_process_from_titelive_ftp, app):
        # mock
        files_list = list()
        files_list.append('Quotidien30.tit')

        get_files_to_process_from_titelive_ftp.return_value = files_list

        data_line = "9782895026310" \
                    "~2895026319" \
                    "~nouvelles du Chili" \
                    "~" \
                    "~0203" \
                    "~1" \
                    "~" \
                    "~" \
                    "~" \
                    "~18,99" \
                    "~LES EDITIONS DE L'INSTANT MEME" \
                    "~EPAGINE" \
                    "~11/05/2011" \
                    "~BL" \
                    "~2" \
                    "~0" \
                    "~0,0" \
                    "~0,0" \
                    "~0,0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~0" \
                    "~Collectif" \
                    "~15/01/2013" \
                    "~02/03/2018" \
                    "~5,50" \
                    "~Littérature Hispano-Portugaise" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~1" \
                    "~3012420280013" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~" \
                    "~0" \
                    "~" \
                    "~369" \
                    "~860" \
                    "~3694440" \
                    "~"
        get_lines_from_thing_file.return_value = iter([data_line])

        # given
        titelive_things_provider = get_provider_by_local_class(
            'TiteLiveThings')

        offerer = create_offerer(siren='775671464')
        venue = create_venue(offerer,
                             name='Librairie Titelive',
                             siret='77567146400110')

        product = create_product_with_thing_type(
            id_at_providers='9782895026310',
            thing_name='Toto à la playa',
            date_modified_at_last_provider=datetime(2001, 1, 1),
            last_provider_id=titelive_things_provider.id)
        PcObject.save(venue, product)

        provider_test(
            app,
            TiteLiveThings,
            None,
            checkedObjects=1,
            createdObjects=0,
            updatedObjects=1,
            erroredObjects=0,
            checkedThumbs=0,
            createdThumbs=0,
            updatedThumbs=0,
            erroredThumbs=0,
        )
        updated_product = Product.query.first()
        assert updated_product.name == 'nouvelles du Chili'
        assert updated_product.extraData.get(
            'bookFormat') == BookFormat.BEAUX_LIVRES.value