예제 #1
0
 def setUp(self):
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
     self.app = TestApp(wufoo_api.app.wsgifunc())
     self.instanceData = {
         "version": "2010-08-31",
         "instanceId": "i-d9e211f6",
         "billingProducts": None,
         "accountId": "987654321",
         "kernelId": "aki-88aa75e1",
         "ramdiskId": None,
         "architecture": "x86_64",
         "imageId": "ami-b56a7fdc",
         "pendingTime": "2014-03-20T14:06:46Z",
         "instanceType": "m1.medium",
         "region": "us-east-1",
         "devpayProductCodes": None,
         "privateIp": "10.122.242.151",
         "availabilityZone": "us-east-1d"
     }
     self.postData = data = {
         "name": "User Schmoozer",
         "company": "Numenta, inc.",
         "edition": "Standard",
         "version": htm.it.__version__.__version__,
         "build": "0",
         "email": "*****@*****.**"
     }
예제 #2
0
    def setUp(self):
        self.headers = getDefaultHTTPHeaders(htm.it.app.config)
        self.app = TestApp(models_api.app.wsgifunc())
        metric = Mock(
            uid="cebe9fab-f416-4845-8dab-02d292244112",
            datasource="cloudwatch",
            description="The number of database connections in use by "
            "Amazon RDS database",
            server="htm-itdb2",
            location="us-east-1",
            parameters=app_utils.jsonEncode({
                "region": "us-east-1",
                "DBInstanceIdentifier": "htm-itdb2"
            }),
            status=1,
            message=None,
            collector_error=None,
            last_timestamp="2013-08-15 21:25:00",
            poll_interval=60,
            tag_name=None,
            model_params=None,
            last_rowid=20277)

        metric.name = "AWS/RDS/DatabaseConnections"
        self.metric = metric
예제 #3
0
 def setUp(self):
     self.app = TestApp(models_api.app.wsgifunc())
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
     data = open(
         os.path.join(
             htm.it.app.HTM_IT_HOME,
             "tests/py/data/app/webservices/models_api_integration_test.json"
         )).read()
     self.modelsTestData = json.loads(data)
예제 #4
0
  def setUpClass(cls):
    cls.autostacksApp = TestApp(autostacks_api.app.wsgifunc())
    cls.cloudwatchApp = TestApp(cloudwatch_api.app.wsgifunc())
    cls.customApp = TestApp(custom_api.app.wsgifunc())
    cls.instancesApp = TestApp(instances_api.app.wsgifunc())
    cls.modelApp = TestApp(models_api.app.wsgifunc())
    cls.headers = getDefaultHTTPHeaders(htm.it.app.config)

    cls.plaintextPort = config.getint("metric_listener", "plaintext_port")
    cls.apiKey = config.get("security", "apikey")
    def setUpClass(cls):
        cls.autostacksApp = TestApp(autostacks_api.app.wsgifunc())
        cls.cloudwatchApp = TestApp(cloudwatch_api.app.wsgifunc())
        cls.customApp = TestApp(custom_api.app.wsgifunc())
        cls.instancesApp = TestApp(instances_api.app.wsgifunc())
        cls.modelApp = TestApp(models_api.app.wsgifunc())
        cls.headers = getDefaultHTTPHeaders(htm.it.app.config)

        cls.plaintextPort = config.getint("metric_listener", "plaintext_port")
        cls.apiKey = config.get("security", "apikey")
예제 #6
0
    def setUp(self):
        self.headers = getDefaultHTTPHeaders(htm.it.app.config)
        self.app = TestApp(notifications_api.app.wsgifunc())

        # Set up dummy notification assets
        self.deviceId = str(uuid.uuid4())
        self.notificationId = str(uuid.uuid4())

        metricParams = {
            u"region": u"us-east-1",
            u"DBInstanceIdentifier": u"htm-itdb2"
        }
        self.metric = {
            "uid": u"cebe9fab-f416-4845-8dab-02d292244112",
            "datasource": u"cloudwatch",
            "name": u"AWS/RDS/DatabaseConnections",
            "description": u"The number of database connections in use "
            u"by Amazon RDS database",
            "server": u"htm-itdb2",
            "location": u"us-east-1",
            "parameters": app_utils.jsonEncode(metricParams),
            "status": 1,
            "message": None,
            "collector_error": None,
            "last_timestamp": u"2013-08-15 21:25:00",
            "poll_interval": 60,
            "tag_name": None,
            "model_params": None,
            "last_rowid": 20277
        }

        self.notification = {
            "uid": self.deviceId,
            "metric": self.metric["uid"],
            "device": self.deviceId,
            "windowsize": 3600,
            "timestamp": datetime.datetime.utcnow(),
            "acknowledged": 0,
            "seen": 0,
            "ses_message_id": None,
            "rowid": 666
        }

        self.settings = {
            "uid": self.deviceId,
            "windowsize": 3600,
            "sensitivity": 0.99999,
            "email_addr": "*****@*****.**",
            "last_timestamp": datetime.datetime.utcnow()
        }
 def setUp(self):
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
     self.app = TestApp(annotations_api.app.wsgifunc())
     self.annotation = {
         "uid": "f4aa70b361f04036b0b39530900f38fa",
         "timestamp": "2014-01-25 05:00:00",
         "created": "2014-01-25 07:14:06",
         "device": "device1",
         "user": "******",
         "server": "htm-itdb2",
         "message": "My annotation",
         "data": None
     }
     # Prepare request as annotation without "uid" or "created" fields
     self.request = self.annotation.copy()
     del self.request["uid"]
     del self.request["created"]
예제 #8
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.app = TestApp(annotations_api.app.wsgifunc())
   self.annotation = {
     "uid": "f4aa70b361f04036b0b39530900f38fa",
     "timestamp": "2014-01-25 05:00:00",
     "created": "2014-01-25 07:14:06",
     "device": "device1",
     "user": "******",
     "server": "htm-itdb2",
     "message": "My annotation",
     "data": None
   }
   # Prepare request as annotation without "uid" or "created" fields
   self.request = self.annotation.copy()
   del self.request["uid"]
   del self.request["created"]
  def setUp(self):
    self.headers = getDefaultHTTPHeaders(htm.it.app.config)
    self.app = TestApp(notifications_api.app.wsgifunc())

    # Set up dummy notification assets
    self.deviceId = str(uuid.uuid4())
    self.notificationId = str(uuid.uuid4())

    metricParams = {u"region":u"us-east-1", u"DBInstanceIdentifier":u"htm-itdb2"}
    self.metric = {"uid": u"cebe9fab-f416-4845-8dab-02d292244112",
                   "datasource": u"cloudwatch",
                   "name": u"AWS/RDS/DatabaseConnections",
                   "description": u"The number of database connections in use "
                                  u"by Amazon RDS database",
                   "server": u"htm-itdb2",
                   "location": u"us-east-1",
                   "parameters": app_utils.jsonEncode(metricParams),
                   "status": 1,
                   "message":None,
                   "collector_error": None,
                   "last_timestamp": u"2013-08-15 21:25:00",
                   "poll_interval": 60,
                   "tag_name": None,
                   "model_params": None,
                   "last_rowid": 20277}

    self.notification = {"uid": self.deviceId,
                         "metric": self.metric["uid"],
                         "device": self.deviceId,
                         "windowsize": 3600,
                         "timestamp": datetime.datetime.utcnow(),
                         "acknowledged": 0,
                         "seen": 0,
                         "ses_message_id": None,
                         "rowid": 666}

    self.settings = {"uid": self.deviceId,
                     "windowsize": 3600,
                     "sensitivity": 0.99999,
                     "email_addr": "*****@*****.**",
                     "last_timestamp": datetime.datetime.utcnow()}
예제 #10
0
  def setUp(self):
    self.headers = getDefaultHTTPHeaders(htm.it.app.config)
    self.app = TestApp(models_api.app.wsgifunc())
    metric = Mock(uid="cebe9fab-f416-4845-8dab-02d292244112",
                  datasource="cloudwatch",
                  description="The number of database connections in use by "
                              "Amazon RDS database",
                  server="htm-itdb2",
                  location="us-east-1",
                  parameters=app_utils.jsonEncode(
                    {"region":"us-east-1", "DBInstanceIdentifier":"htm-itdb2"}),
                  status=1,
                  message=None,
                  collector_error=None,
                  last_timestamp="2013-08-15 21:25:00",
                  poll_interval=60,
                  tag_name=None,
                  model_params=None,
                  last_rowid=20277)

    metric.name = "AWS/RDS/DatabaseConnections"
    self.metric = metric
예제 #11
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.app = TestApp(wufoo_api.app.wsgifunc())
   self.instanceData = {"version" : "2010-08-31",
                        "instanceId" : "i-d9e211f6",
                        "billingProducts" : None,
                        "accountId" : "987654321",
                        "kernelId" : "aki-88aa75e1",
                        "ramdiskId" : None,
                        "architecture" : "x86_64",
                        "imageId" : "ami-b56a7fdc",
                        "pendingTime" : "2014-03-20T14:06:46Z",
                        "instanceType" : "m1.medium",
                        "region" : "us-east-1",
                        "devpayProductCodes" : None,
                        "privateIp" : "10.122.242.151",
                        "availabilityZone" : "us-east-1d"}
   self.postData = data = {"name": "User Schmoozer",
                           "company": "Numenta, inc.",
                           "edition": "Standard",
                           "version": htm.it.__version__.__version__,
                           "build": "0",
                           "email": "*****@*****.**"}
  def setUp(self):
    self.headers = getDefaultHTTPHeaders(app_config)
    self.invalidHeaders = getInvalidHTTPHeaders()
    self.app = TestApp(annotations_api.app.wsgifunc())
    self.annotation = {
        "uid": "f4aa70b361f04036b0b39530900f38fa",
        "timestamp": "2014-01-25 05:00:00",
        "created": "2014-01-25 07:14:06",
        "device": "device1",
        "user": "******",
        "server": "us-west-2/AWS/EC2/i-f52075fe",
        "message": "My annotation",
        "data": None
    }
    self.instanceId = "%s/AWS/EC2/%s" % (
        VALID_EC2_INSTANCES["region"],
        VALID_EC2_INSTANCES["instanceId"])

    # Prepare request as annotation without "uid" or "created" fields
    self.request = self.annotation.copy()
    self.request["server"] = self.instanceId
    del self.request["uid"]
    del self.request["created"]
 def setUp(self):
   self.app = TestApp(models_api.app.wsgifunc())
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.data = self.createTestData()
예제 #14
0
  def setUpClass(cls):
    """
    Setup steps for all test cases.
    Focus for these is to cover all API checks for ModelDataHandler.
    Hence, this does all setup creating metric, waiting for
    metricData across all testcases, all API call for querying metricData
    will be against single metric created in setup
    Setup Process
    1) Update conf with aws credentials, ManagedTempRepository will not
       work in this test
    2) Select test instance such that its running from longer time,
       We are using instance older than 15 days
    3) Create Metric, wait for min metricData rows to become available
       Set to 100, configurable
    4) Pick testRowId, set it lower value this will make sure to have
       Non NULL value for anomaly_score field for given row while invoking
       GET with consitions, set to 5
    5) Decide queryParams for anomalyScore, to and from timestamp
    """
    cls.headers = getDefaultHTTPHeaders(htm.it.app.config)

    # All other sevices needs AWS credentials to work
    # Set AWS credentials
    htm.it.app.config.loadConfig()

    # Select test instance such that its running from longer time
    g_logger.info("Getting long-running EC2 Instances")
    instances = aws_utils.getLongRunningEC2Instances("us-west-2",
      htm.it.app.config.get("aws", "aws_access_key_id"),
      htm.it.app.config.get("aws", "aws_secret_access_key"), 15)
    testInstance = instances[randrange(1, len(instances))]

    createModelData = {
      "region": "us-west-2",
      "namespace": "AWS/EC2",
      "datasource": "cloudwatch",
      "metric": "CPUUtilization",
      "dimensions": {
        "InstanceId": testInstance.id
      }
    }

    # Number of minimum rows
    cls.minDataRows = 100

    cls.app = TestApp(models_api.app.wsgifunc())

    # create test metric
    g_logger.info("Creating test metric; modelSpec=%s", createModelData)
    response = cls.app.put("/", utils.jsonEncode(createModelData),
     headers=cls.headers)
    postResult = utils.jsonDecode(response.body)
    maxWaitTime = 600
    waitTimeMetricData = 0
    waitAnomalyScore = 0


    # Wait for enough metric data to be available
    cls.uid = postResult[0]["uid"]
    engine = repository.engineFactory()
    with engine.connect() as conn:
      cls.metricData = [row for row
                         in repository.getMetricData(conn, cls.uid)]
    with engine.connect() as conn:
      cls.testMetric = repository.getMetric(conn, cls.uid)

    # Confirm that we have enough metricData
    g_logger.info("Waiting for metric data")
    while (len(cls.metricData) < cls.minDataRows and
           waitTimeMetricData < maxWaitTime):
      g_logger.info("not ready, waiting for metric data: got %d of %d ...",
                    len(cls.metricData), cls.minDataRows)
      time.sleep(5)
      waitTimeMetricData += 5
      with engine.connect() as conn:
        cls.metricData = [row for row
                           in repository.getMetricData(conn, cls.uid)]

    # taking lower value for testRowId, this will make sure to have
    # Non NULL value for anomaly_score field for given row
    cls.testRowId = 5

    with engine.connect() as conn:
      cls.testMetricRow = (repository.getMetricData(conn,
                                                     cls.uid,
                                                     rowid=cls.testRowId)
                          .fetchone())

    # Make sure we did not receive None etc for anomaly score
    g_logger.info("cls.testMetricRow.anomaly_score=%r",
                  cls.testMetricRow.anomaly_score)
    g_logger.info("waitAnomalyScore=%r", waitAnomalyScore)
    while (cls.testMetricRow.anomaly_score is None and
           waitAnomalyScore < maxWaitTime):
      g_logger.info("anomaly_score not ready, sleeping...")
      time.sleep(5)
      waitAnomalyScore += 5
      with engine.connect() as conn:
        cls.testMetricRow = (repository.getMetricData(conn,
                                                      cls.uid,
                                                      rowid=cls.testRowId)
                            .fetchone())

    # Decide queryParams for anomalyScore, to and from timestamp
    cls.testAnomalyScore = cls.testMetricRow.anomaly_score
    cls.testTimeStamp = cls.testMetricRow.timestamp
예제 #15
0
 def setUp(self):
   self.app = TestApp(models_api.app.wsgifunc())
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   data = open(os.path.join(htm.it.app.HTM_IT_HOME,
    "tests/py/data/app/webservices/models_api_integration_test.json")).read()
   self.modelsTestData = json.loads(data)
예제 #16
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.app = TestApp(webapp.app.wsgifunc())
 def setUp(self):
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
     self.app = TestApp(autostacks_api.app.wsgifunc())
예제 #18
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.app = TestApp(anomalies_api.app.wsgifunc())
예제 #19
0
 def setUp(self):
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
     self.app = TestApp(webapp.app.wsgifunc())
 def setUp(self):
     self.app = TestApp(instances_api.app.wsgifunc())
     self.headers = getDefaultHTTPHeaders(config)
예제 #21
0
 def setUp(self):
   self.app = TestApp(cloudwatch_api.app.wsgifunc())
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
예제 #22
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
예제 #23
0
 def setUp(self):
   self.app = TestApp(cloudwatch_api.app.wsgifunc())
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
 def setUp(self):
     self.app = TestApp(instances_api.app.wsgifunc())
     self.headers = getDefaultHTTPHeaders(config)
예제 #25
0
 def setUp(self):
     self.headers = getDefaultHTTPHeaders(htm.it.app.config)
예제 #26
0
 def setUp(self):
   self.headers = getDefaultHTTPHeaders(htm.it.app.config)
   self.app = TestApp(cloudwatch_api.app.wsgifunc())
   adapter = datasource_adapter_factory.createCloudwatchDatasourceAdapter()
   self.resources = adapter.describeSupportedMetrics()
   self.regions = adapter.describeRegions()