You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
611 lines
18 KiB
611 lines
18 KiB
<?php
|
|
/*
|
|
** Zabbix
|
|
** Copyright (C) 2001-2023 Zabbix SIA
|
|
**
|
|
** This program is free software; you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation; either version 2 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program; if not, write to the Free Software
|
|
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
**/
|
|
|
|
require_once dirname(__FILE__).'/../include/CIntegrationTest.php';
|
|
require_once dirname(__FILE__).'/../include/CAPITest.php';
|
|
|
|
/**
|
|
* Test suite for history.push API methods (pushing of history)
|
|
*
|
|
* @required-components server
|
|
* @configurationDataProvider serverConfigurationProvider
|
|
* @hosts test_history_push1,test_history_push_non_monitored,test_history_push_maintained
|
|
* @backup history,items,hosts,history_uint,history_text,history_str,history_log,ids
|
|
*/
|
|
class testHistoryPush extends CIntegrationTest {
|
|
const HOSTNAME1 = 'test_history_push1';
|
|
|
|
private static $hostid_normal;
|
|
private static $hostid_non_monitored;
|
|
private static $hostid_maintained;
|
|
private static $itemids;
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
public function prepareData() {
|
|
// Create host "test_history_push1"
|
|
$response = $this->call('host.create', [
|
|
[
|
|
'host' => self::HOSTNAME1,
|
|
'interfaces' => [],
|
|
'groups' => [['groupid' => 4]],
|
|
'status' => HOST_STATUS_MONITORED
|
|
]
|
|
]);
|
|
|
|
$this->assertArrayHasKey('hostids', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['hostids']);
|
|
self::$hostid_normal = $response['result']['hostids'][0];
|
|
|
|
// Create host "test_history_push_non_monitored"
|
|
$response = $this->call('host.create', [
|
|
[
|
|
'host' => "test_history_push_non_monitored",
|
|
'interfaces' => [],
|
|
'groups' => [['groupid' => 4]],
|
|
'status' => HOST_STATUS_NOT_MONITORED
|
|
]
|
|
]);
|
|
|
|
$this->assertArrayHasKey('hostids', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['hostids']);
|
|
self::$hostid_non_monitored = $response['result']['hostids'][0];
|
|
|
|
// Create host "test_history_push_maintained"
|
|
$response = $this->call('host.create', [
|
|
[
|
|
'host' => "test_history_push_maintained",
|
|
'interfaces' => [],
|
|
'groups' => [['groupid' => 4]],
|
|
'status' => HOST_STATUS_MONITORED
|
|
]
|
|
]);
|
|
$this->assertArrayHasKey('hostids', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['hostids']);
|
|
self::$hostid_maintained = $response['result']['hostids'][0];
|
|
|
|
// Create items
|
|
$items = [
|
|
[
|
|
'key_' => 'calc_item',
|
|
'type' => ITEM_TYPE_CALCULATED,
|
|
'params' => '1',
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64,
|
|
'delay' => '3s'
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint2',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_host_key_test',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_no_perms',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_bad_valuetype',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_disabled',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64,
|
|
'status' => ITEM_STATUS_DISABLED
|
|
],
|
|
[
|
|
'key_' => 'trapper_float',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_FLOAT
|
|
],
|
|
[
|
|
'key_' => 'trapper_log',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_LOG
|
|
],
|
|
[
|
|
'key_' => 'trapper_text',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_TEXT
|
|
],
|
|
[
|
|
'key_' => 'trapper_str',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_STR
|
|
],
|
|
[
|
|
'key_' => 'trapper_text_bad_allow_hosts',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_TEXT,
|
|
'trapper_hosts' => 'non.existent.host'
|
|
],
|
|
[
|
|
'key_' => 'http_agent_text',
|
|
'type' => ITEM_TYPE_HTTPAGENT,
|
|
'value_type' => ITEM_VALUE_TYPE_TEXT,
|
|
'url' => 'http://127.0.0.1/test',
|
|
'delay' => '10s',
|
|
'allow_traps' => 1
|
|
],
|
|
[
|
|
'key_' => 'http_agent_text_no_trap',
|
|
'type' => ITEM_TYPE_HTTPAGENT,
|
|
'value_type' => ITEM_VALUE_TYPE_TEXT,
|
|
'url' => 'http://127.0.0.1/test',
|
|
'delay' => '10s',
|
|
'allow_traps' => 0
|
|
]
|
|
];
|
|
|
|
foreach ($items as $item) {
|
|
$item['name'] = $item['key_'];
|
|
$item['hostid'] = self::$hostid_normal;
|
|
|
|
$response = $this->call('item.create', $item);
|
|
$this->assertArrayHasKey('itemids', $response['result']);
|
|
$this->assertEquals(1, count($response['result']['itemids']));
|
|
|
|
$itemid = $response['result']['itemids'][0];
|
|
self::$itemids[$item['key_']] = $itemid;
|
|
}
|
|
|
|
$items_nonavail_hosts = [
|
|
[
|
|
'key_' => 'trapper_uint_non_monitored_host',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64,
|
|
'hostid' => self::$hostid_non_monitored
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_maintained_host',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64,
|
|
'hostid' => self::$hostid_maintained
|
|
],
|
|
[
|
|
'key_' => 'trapper_uint_no_perms_host',
|
|
'type' => ITEM_TYPE_TRAPPER,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64,
|
|
'hostid' => self::$hostid_normal
|
|
]
|
|
];
|
|
|
|
foreach ($items_nonavail_hosts as $item) {
|
|
$item['name'] = $item['key_'];
|
|
|
|
$response = $this->call('item.create', $item);
|
|
$this->assertArrayHasKey('itemids', $response['result']);
|
|
$this->assertEquals(1, count($response['result']['itemids']));
|
|
|
|
$itemid = $response['result']['itemids'][0];
|
|
self::$itemids[$item['key_']] = $itemid;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Component configuration provider for agent related tests.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function serverConfigurationProvider() {
|
|
return [
|
|
self::COMPONENT_SERVER => [
|
|
'LogFileSize' => 0,
|
|
'DebugLevel' => 5
|
|
]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Push value of every type.
|
|
*
|
|
* @backup history_uint,history_text,history,history_str,history_log
|
|
*/
|
|
public function testHistoryPush_pushSingleTrapperValue() {
|
|
$tcs = [
|
|
[
|
|
'itemid' => self::$itemids['trapper_uint'],
|
|
'value' => 1,
|
|
'value_type' => ITEM_VALUE_TYPE_UINT64
|
|
],
|
|
[
|
|
'itemid' => self::$itemids['trapper_log'],
|
|
'value' => 'somelog',
|
|
'value_type' => ITEM_VALUE_TYPE_LOG
|
|
],
|
|
[
|
|
'itemid' => self::$itemids['trapper_float'],
|
|
'value' => 1.7,
|
|
'value_type' => ITEM_VALUE_TYPE_FLOAT
|
|
],
|
|
[
|
|
'itemid' => self::$itemids['trapper_str'],
|
|
'value' => 'somestr',
|
|
'value_type' => ITEM_VALUE_TYPE_STR
|
|
],
|
|
[
|
|
'itemid' => self::$itemids['http_agent_text'],
|
|
'value' => 'sometext',
|
|
'value_type' => ITEM_VALUE_TYPE_TEXT
|
|
]
|
|
];
|
|
|
|
foreach ($tcs as $tc) {
|
|
$value_sent = [
|
|
'itemid' => $tc['itemid'],
|
|
'value' => $tc['value'],
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
];
|
|
|
|
$response = $this->call('history.push', [
|
|
$value_sent
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertEquals(1, count($response['result']['data']));
|
|
$this->assertArrayHasKey('itemid', $response['result']['data'][0]);
|
|
$this->assertEquals($tc['itemid'], $response['result']['data'][0]['itemid']);
|
|
$this->assertArrayNotHasKey('error', $response['result']['data'][0]);
|
|
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'In trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
|
|
$response = $this->call('history.get', [
|
|
'output' => ['itemid', 'value', 'clock', 'ns'],
|
|
'itemids' => [$tc['itemid']],
|
|
'sortorder' => 'DESC',
|
|
'sortfield' => 'clock',
|
|
'limit' => 1,
|
|
'history' => $tc['value_type']
|
|
]);
|
|
$this->assertEquals(1, count($response['result']));
|
|
$value_retrieved = $response['result'][0];
|
|
|
|
foreach (array_keys($value_retrieved) as $i) {
|
|
$this->assertEquals(strval($value_sent[$i]), $value_retrieved[$i]);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function testHistoryPush_pushSingleValueHostKey() {
|
|
$value_sent = [
|
|
'host' => self::HOSTNAME1,
|
|
'key' => 'trapper_uint_host_key_test',
|
|
'value' => 123,
|
|
'clock' => time() - 25,
|
|
'ns' => 500
|
|
];
|
|
|
|
$response = $this->call('history.push', $value_sent);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertEquals(1, count($response['result']['data']));
|
|
$this->assertArrayHasKey('itemid', $response['result']['data'][0]);
|
|
$this->assertEquals(self::$itemids['trapper_uint_host_key_test'], $response['result']['data'][0]['itemid']);
|
|
$this->assertArrayNotHasKey('error', $response['result']['data'][0]);
|
|
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'In trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
|
|
$response = $this->call('history.get', [
|
|
'output' => ['value', 'clock', 'ns'],
|
|
'itemids' => [self::$itemids['trapper_uint_host_key_test']],
|
|
'sortorder' => 'DESC',
|
|
'sortfield' => 'clock',
|
|
'limit' => 1
|
|
]);
|
|
$this->assertEquals(1, count($response['result']));
|
|
$value_retrieved = $response['result'][0];
|
|
$this->assertEquals($value_sent['value'], $value_retrieved['value']);
|
|
$this->assertEquals($value_sent['clock'], $value_retrieved['clock']);
|
|
$this->assertEquals($value_sent['ns'], $value_retrieved['ns']);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Push multiple values of different types in single request.
|
|
*
|
|
* @backup history_uint, history_text
|
|
*/
|
|
public function testHistoryPush_pushMultipleValues() {
|
|
$values_sent_uint = [];
|
|
$values_sent_text = [];
|
|
$values_sent = [];
|
|
$idx = 0;
|
|
|
|
for (; $idx < 5; $idx++) {
|
|
$values_sent_uint[] = [
|
|
'itemid' => self::$itemids['trapper_uint2'],
|
|
'value' => 1 + $idx,
|
|
'clock' => time() - 20 + $idx,
|
|
'ns' => intval(time() / 10000 + 25 * $idx)
|
|
];
|
|
}
|
|
for (; $idx < 10; $idx++) {
|
|
$values_sent_text[] = [
|
|
'itemid' => self::$itemids['trapper_text'],
|
|
'value' => "zabbix$idx",
|
|
'clock' => time() - 15 + $idx,
|
|
'ns' => intval(time() / 10000 + 25 * $idx)
|
|
];
|
|
}
|
|
|
|
$values_sent = array_merge($values_sent_uint, $values_sent_text);
|
|
|
|
$response = $this->call('history.push', $values_sent);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertEquals(count($values_sent), count($response['result']['data']));
|
|
foreach ($response['result']['data'] as $rec) {
|
|
$this->assertFalse(array_key_exists('error', $rec),
|
|
"key 'error' exists in a response (itemid: ".$rec['itemid'].")");
|
|
}
|
|
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'In trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of trapper_process_history_push', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER, 'End of DBmass_add_history', true, 95, 3);
|
|
|
|
$response = $this->call('history.get', [
|
|
'output' => ['itemid', 'value', 'clock', 'ns'],
|
|
'history' => ITEM_VALUE_TYPE_TEXT,
|
|
'itemids' => self::$itemids['trapper_text'],
|
|
'sortfield' => 'clock',
|
|
'sortorder' => 'ASC'
|
|
]);
|
|
$this->assertEquals($values_sent_text, $response['result']);
|
|
|
|
$response = $this->call('history.get', [
|
|
'output' => ['itemid', 'value', 'clock', 'ns'],
|
|
'itemids' => self::$itemids['trapper_uint2'],
|
|
'sortfield' => 'clock',
|
|
'sortorder' => 'ASC'
|
|
]);
|
|
$this->assertEquals($values_sent_uint, $response['result']);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function testHistoryPush_serverIsDown() {
|
|
$this->stopComponent(self::COMPONENT_SERVER);
|
|
|
|
// CAPITest::call() has assertions for 'result' key in a response, these will throw an exception
|
|
$this->expectException(\PHPUnit\Framework\ExpectationFailedException::class);
|
|
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['trapper_uint'],
|
|
'value' => 1,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
}
|
|
|
|
public function testHistoryPush_httpAgentTrappingDisabled() {
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['http_agent_text_no_trap'],
|
|
'value' => 'a',
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_invalidItemid() {
|
|
$response = $this->call('history.push', [
|
|
'itemid' => 99999,
|
|
'value' => 1,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_disabledItem() {
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['trapper_uint_disabled'],
|
|
'value' => 1,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_notSupportedItemType() {
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['calc_item'],
|
|
'value' => 'x',
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_nonMonitoredHost() {
|
|
$response = $this->call('host.update', [
|
|
'hostid' => self::$hostid_non_monitored,
|
|
'status' => 1
|
|
]);
|
|
|
|
$this->reloadConfigurationCache();
|
|
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['trapper_uint_non_monitored_host'],
|
|
'value' => 999,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_hostUnderMaintenance() {
|
|
$maint_start_tm = time();
|
|
$maint_end_tm = $maint_start_tm + 60 * 2;
|
|
|
|
$response = $this->call('maintenance.create', [
|
|
'name' => 'Test maintenance',
|
|
'hosts' => ['hostid' => self::$hostid_maintained],
|
|
'active_since' => $maint_start_tm,
|
|
'active_till' => $maint_end_tm,
|
|
'maintenance_type' => MAINTENANCE_TYPE_NODATA,
|
|
'timeperiods' => [
|
|
'timeperiod_type' => TIMEPERIOD_TYPE_ONETIME,
|
|
'period' => 300,
|
|
'start_date' => $maint_start_tm
|
|
]
|
|
]);
|
|
|
|
$this->assertArrayHasKey('maintenanceids', $response['result']);
|
|
$this->assertEquals(1, count($response['result']['maintenanceids']));
|
|
$maintenance_id = $response['result']['maintenanceids'][0];
|
|
|
|
$this->reloadConfigurationCache();
|
|
$this->waitForLogLineToBePresent(self::COMPONENT_SERVER,
|
|
'End of zbx_dc_update_maintenances() started:1 stopped:0 running:1', true);
|
|
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['trapper_uint_maintained_host'],
|
|
'value' => 12345,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_clientNotInAllowedHosts() {
|
|
$response = $this->call('history.push', [
|
|
'itemid' => self::$itemids['trapper_text_bad_allow_hosts'],
|
|
'value' => 12345,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_noPermission() {
|
|
$response = $this->call('user.create', [
|
|
'username' => 'John',
|
|
'passwd' => 'Doe123123',
|
|
'roleid' => 1,
|
|
'usrgrps' => [['usrgrpid' => 8]]
|
|
|
|
]);
|
|
$this->assertArrayHasKey('userids', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['userids']);
|
|
$userid = $response['result']['userids'][0];
|
|
|
|
$this->authorize('John', 'Doe123123');
|
|
$value_sent = [
|
|
'itemid' => self::$itemids['trapper_uint_no_perms'],
|
|
'value' => 1,
|
|
'clock' => time() - 25,
|
|
'ns' => 255
|
|
];
|
|
|
|
$response = $this->call('history.push', [
|
|
$value_sent
|
|
]);
|
|
|
|
$this->assertArrayHasKey('data', $response['result']);
|
|
$this->assertArrayHasKey(0, $response['result']['data']);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][0]);
|
|
}
|
|
|
|
public function testHistoryPush_duplicateTimestamp() {
|
|
$tm = time();
|
|
|
|
$response = $this->call('history.push', [
|
|
[
|
|
'itemid' => self::$itemids['trapper_uint'],
|
|
'value' => 1,
|
|
'clock' => $tm,
|
|
'ns' => 500
|
|
],
|
|
[
|
|
'itemid' => self::$itemids['trapper_uint'],
|
|
'value' => 0,
|
|
'clock' => $tm,
|
|
'ns' => 500
|
|
]
|
|
]);
|
|
|
|
$this->assertEquals(2, count($response['result']['data']));
|
|
$this->assertArrayNotHasKey('error', $response['result']['data'][0]);
|
|
$this->assertArrayHasKey('error', $response['result']['data'][1]);
|
|
}
|
|
|
|
public function testHistoryPush_malformedRequest() {
|
|
// CAPITest::call() has assertions for 'result' key in a response, these will throw an exception
|
|
$this->expectException(\PHPUnit\Framework\ExpectationFailedException::class);
|
|
|
|
$response = $this->call('history.push', [
|
|
[
|
|
'host' => "10000",
|
|
'value' => 1,
|
|
'clock' => time(),
|
|
'ns' => 500
|
|
]
|
|
]);
|
|
}
|
|
}
|