示例#1
0
  def setUp(self):
    # Create a mock client
    self.client = Mock(spec=Client)
    self.client.c = Mock(spec=Connection)

    # Create our minimal streamDef
    self.streamDef = \
      {
        'cloneUrl': 'http://example.com',
        'dataUrl': 'http://example.com',
        'url': 'http://example.com',
        'dataSources': \
          [
            {
              'name': 'My Data Source',
              'dataSourceType': 'local',
              'fields': \
                [
                  {
                    'name': 'x',
                    'dataFormat': \
                      {
                        'dataType': 'SCALAR'
                      }
                  }
                ]
            }
         ]
      }

    # Instantiate the stream
    self.s = Stream(self.client, self.streamDef)
示例#2
0
class StreamTestCase(GrokTestCase):

  def setUp(self):
    # Create a mock client
    self.client = Mock(spec=Client)
    self.client.c = Mock(spec=Connection)

    # Create our minimal streamDef
    self.streamDef = \
      {
        'cloneUrl': 'http://example.com',
        'dataUrl': 'http://example.com',
        'url': 'http://example.com',
        'dataSources': \
          [
            {
              'name': 'My Data Source',
              'dataSourceType': 'local',
              'fields': \
                [
                  {
                    'name': 'x',
                    'dataFormat': \
                      {
                        'dataType': 'SCALAR'
                      }
                  }
                ]
            }
         ]
      }

    # Instantiate the stream
    self.s = Stream(self.client, self.streamDef)

  def testAddRecordsLowSplit(self):
    '''
    A low split number should throw an error.
    '''

    self.client.c.request.side_effect = GrokError("Boom!")

    # Make some dummy records
    records = []
    for i in range(50):
      records.append([0])

    self.assertRaises(GrokError, self.s.addRecords, records, 40)

  def testAddRecordsSmallRecordCount(self):
    '''
    Should pass without comment
    '''

    # Make some dummy records
    records = []
    for i in range(50):
      records.append([0])

    self.s.addRecords(records)

  def testAddRecordsLargeRecordCountBad(self):
    '''
    Should raise an error eventually
    '''

    self.client.c.request.side_effect = GrokError("Boom!")

    # Make some dummy records
    records = []
    for i in range(5000):
      records.append([0])

    self.assertRaises(GrokError, self.s.addRecords, records)

  def testAddRecordsRaisesGrokErrorForEmptyInput(self):
    '''
    Should raise an error immediately
    '''

    self.assertRaises(GrokError, self.s.addRecords, [])
    self.assertRaises(GrokError, self.s.addRecords, None)
    self.assertRaises(GrokError, self.s.addRecords, '')


  def testAddRecordsLargeRecordCountGood(self):
    '''
    Should pass without comment
    '''

    # Make some dummy records
    records = []
    for i in range(5000):
      records.append([0])


    self.s.addRecords(records)

  def testDelete(self):
    '''
    No-op in unit test context
    '''

    self.s.delete()

  def testGetSpecDict(self):
    '''
    We should get back the same data we put in
    '''

    self.assertEqual(self.s.getSpecDict(), self.streamDef)

  def testAddRecordsWithPythonDatetimes(self):
    '''
    Records that include datetime objects should be silently converted to
    strings and passed on without error
    '''

    datetimeField = \
      {
        'name': 'timestamp',
        'flag': 'TIMESTAMP',
        'dataFormat': \
          {
            'dataType': 'DATETIME'
          }
      }

    self.s.dataSources[0]['fields'].insert(0, datetimeField)

    # Make some dummy records
    records = []
    for i in range(10):
      records.append([datetime.now(), i])

    self.s.addRecords(records)

  def testStreamClone(self):
    ''' User can clone a stream '''
    self.client.c.request.return_value={'stream': self.streamDef}
    clone = self.s.clone()
    self.client.c.request.assert_called_with('POST', self.streamDef['cloneUrl'])
    self.assertIsInstance(clone, Stream)
    self.assertNotEqual(id(clone), id(self.s))

  def testStreamCloneWithOverride(self):
    ''' User can clone a stream, overriding params '''
    overrideParams = {'description': 'foo'}
    streamDef = dict(**self.streamDef)
    streamDef.update(**overrideParams)
    self.client.c.request.return_value = {'stream': streamDef}
    clone = self.s.clone(params=overrideParams)
    self.client.c.request.assert_called_with(
      'POST',
      self.streamDef['cloneUrl'],
      {'stream':overrideParams})
    self.assertIsInstance(clone, Stream)
    self.assertNotEqual(id(clone), id(self.s))