Beispiel #1
0
 def __init__(self):
     try:
         mode = os.environ["espa_api_testing"]
         if mode is not "True":
             raise ("MockOrder objects only allowed while testing")
     except:
         raise MockOrderException(
             "MockOrder objects only allowed while testing")
     self.base_order = build_base_order()
     self.ordering_provider = OrderingProvider()
     self.production_provider = ProductionProvider()
Beispiel #2
0
 def __init__(self):
     try:
         mode = os.environ["espa_api_testing"]
         if mode is not "True":
             raise("MockOrder objects only allowed while testing")
     except:
         raise MockOrderException("MockOrder objects only allowed while testing")
     self.base_order = build_base_order()
     self.ordering_provider = OrderingProvider()
     self.production_provider = ProductionProvider()
Beispiel #3
0
class DefaultProviders(object):

    ordering = OrderingProvider()

    validation = ValidationProvider()

    metrics = MetricsProvider()

    inventory = InventoryProvider()

    production = ProductionProvider()

    configuration = ConfigurationProvider()

    reporting = ReportingProvider()

    administration = AdministrationProvider()
Beispiel #4
0
class MockOrder(object):
    """ Class for interacting with the ordering_order table """

    def __init__(self):
        try:
            mode = os.environ["espa_api_testing"]
            if mode is not "True":
                raise("MockOrder objects only allowed while testing")
        except:
            raise MockOrderException("MockOrder objects only allowed while testing")
        self.base_order = build_base_order()
        self.ordering_provider = OrderingProvider()
        self.production_provider = ProductionProvider()

    def __repr__(self):
        return "MockOrder:{0}".format(self.__dict__)

    def generate_testing_order(self, user_id):
        user = User.find(user_id)
        # need to monkey with the email, otherwise we get collisions with each
        # test creating a new scratch order with the same user
        rand = str(random.randint(1, 99))
        user.email = rand + user.email
        orderid = self.ordering_provider.place_order(self.base_order, user)
        order = Order.find(orderid)
        return order.id

    def generate_ee_testing_order(self, user_id, partial=False):
        ee_order = mock_lta.get_available_orders_partial(partial)

        # Have to emulate a bunch of load_ee_orders

        for eeorder, email_addr, contactid in ee_order:
            order_id = Order.generate_ee_order_id(email_addr, eeorder)
            scene_info = ee_order[eeorder, email_addr, contactid]

            user = User.find(user_id)
            ts = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')

            order_dict = {'orderid': order_id,
                          'user_id': user.id,
                          'order_type': 'level2_ondemand',
                          'status': 'ordered',
                          'note': 'EarthExplorer order id: {}'.format(eeorder),
                          'ee_order_id': eeorder,
                          'order_source': 'ee',
                          'order_date': ts,
                          'priority': 'normal',
                          'email': user.email,
                          'product_options': 'include_sr: true',
                          'product_opts': Order.get_default_ee_options(scene_info)}

            order = Order.create(order_dict)
            self.production_provider.load_ee_scenes(scene_info, order.id)

        return order.id

    def scene_names_list(self, order_id):
        scenes = Scene.where({'order_id': order_id})
        names_list = [s.name for s in scenes]
        return names_list

    def tear_down_testing_orders(self):
        # delete scenes first
        scene_sql = "DELETE FROM ordering_scene where id > 0;"
        with db_instance() as db:
            db.execute(scene_sql)
            db.commit()
        # now you can delete orders
        ord_sql = "DELETE FROM ordering_order where id > 0;"
        with db_instance() as db:
            db.execute(ord_sql)
            db.commit()
        return True

    def update_scenes(self, order_id, attribute, values):
        scenes = Scene.where({'order_id': order_id})
        xscenes = chunkify(scenes, len(values))

        for idx, value in enumerate(values):
            for scene in xscenes[idx]:
                scene.update(attribute, value)
        return True

    def names_tuple(self, number, user_id):
        order_id = self.generate_testing_order(user_id)
        order = Order.find(order_id)
        scene_names = [i.name for i in order.scenes()]
        scene_names = scene_names[0:number]
        list_of_tuples = [(order.orderid, s) for s in scene_names]
        return list_of_tuples
from api.domain.order import Order, OptionsConversion
from api.domain.scene import Scene
from api.domain.user import User
from api.external.mocks import lta, inventory, lpdaac, onlinecache, hadoop
from api.interfaces.production.version1 import API
from api.notification import emails
from api.providers.configuration.configuration_provider import ConfigurationProvider
from api.providers.production.mocks.production_provider import MockProductionProvider
from api.providers.production.production_provider import ProductionProvider
from api.providers.ordering.ordering_provider import OrderingProvider, OrderingProviderException
from api.system.mocks import errors
from mock import patch
from copy import deepcopy

api = API()
ordering_provider = OrderingProvider()
production_provider = ProductionProvider()
mock_production_provider = MockProductionProvider()
cfg = ConfigurationProvider()


class TestProductionAPI(unittest.TestCase):
    def setUp(self):
        os.environ['espa_api_testing'] = 'True'
        # create a user
        self.mock_user = MockUser()
        self.mock_order = MockOrder()
        self.user_id = self.mock_user.add_testing_user()

    def tearDown(self):
        # clean up orders
Beispiel #6
0
class MockOrder(object):
    """ Class for interacting with the ordering_order table """
    def __init__(self):
        try:
            mode = os.environ["espa_api_testing"]
            if mode is not "True":
                raise ("MockOrder objects only allowed while testing")
        except:
            raise MockOrderException(
                "MockOrder objects only allowed while testing")
        self.base_order = build_base_order()
        self.ordering_provider = OrderingProvider()
        self.production_provider = ProductionProvider()

    def __repr__(self):
        return "MockOrder:{0}".format(self.__dict__)

    def as_dict(self):
        return {
            "completion_date": '',
            "note": '',
            "order_date": '',
            "order_source": '',
            "order_type": '',
            "orderid": '',
            "priority": '',
            "product_options": '',
            "product_opts": '',
            "status": ''
        }

    def generate_testing_order(self, user_id):
        user = User.find(user_id)
        # need to monkey with the email, otherwise we get collisions with each
        # test creating a new scratch order with the same user
        rand = str(random.randint(1, 99))
        user.email = rand + user.email
        order = self.ordering_provider.place_order(self.base_order, user)
        return order.id

    def generate_ee_testing_order(self, user_id, partial=False):
        ee_order = mock_lta.get_available_orders_partial(partial)

        # Have to emulate a bunch of load_ee_orders

        for eeorder, email_addr, contactid in ee_order:
            order_id = Order.generate_ee_order_id(email_addr, eeorder)
            scene_info = ee_order[eeorder, email_addr, contactid]

            user = User.find(user_id)
            ts = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')

            order_dict = {
                'orderid': order_id,
                'user_id': user.id,
                'order_type': 'level2_ondemand',
                'status': 'ordered',
                'note': 'EarthExplorer order id: {}'.format(eeorder),
                'ee_order_id': eeorder,
                'order_source': 'ee',
                'order_date': ts,
                'priority': 'normal',
                'email': user.email,
                'product_options': 'include_sr: true',
                'product_opts': Order.get_default_ee_options(scene_info)
            }

            order = Order.create(order_dict)
            self.production_provider.load_ee_scenes(scene_info, order.id)

        return order.id

    def scene_names_list(self, order_id):
        scenes = Scene.where({'order_id': order_id})
        names_list = [s.name for s in scenes]
        return names_list

    def tear_down_testing_orders(self):
        # delete scenes first
        scene_sql = "DELETE FROM ordering_scene where id > 0;"
        with db_instance() as db:
            db.execute(scene_sql)
            db.commit()
        # now you can delete orders
        ord_sql = "DELETE FROM ordering_order where id > 0;"
        with db_instance() as db:
            db.execute(ord_sql)
            db.commit()
        return True

    def update_scenes(self, order_id, stype, attribute, values):
        scenes = Scene.where({'order_id': order_id, 'sensor_type': stype})
        xscenes = chunkify(scenes, len(values))

        for idx, value in enumerate(values):
            for scene in xscenes[idx]:
                scene.update(attribute, value)
        return True

    def names_tuple(self, number, user_id):
        order_id = self.generate_testing_order(user_id)
        order = Order.find(order_id)
        scene_names = [i.name for i in order.scenes()]
        scene_names = scene_names[0:number]
        list_of_tuples = [(order.orderid, s) for s in scene_names]
        return list_of_tuples

    @classmethod
    def place_order(cls, order, user):
        self = MockOrder()
        # need to monkey with the email, otherwise we get collisions with each
        # test creating a new scratch order with the same user
        rand = str(random.randint(1, 99))
        user.email = rand + user.email
        order = self.ordering_provider.place_order(self.base_order, user)
        return order

    @classmethod
    def cancel_order(cls, orderid, request_address):
        order = Order.find(orderid)
        order.status = 'cancelled'
        order.save()
        return order