test-internal-metadata.js

exports.list_invalid_empty_metadata_key = function (t) {
    var expectedError = {
        code: 'ValidationFailed',
        message: 'Invalid Parameters',
        errors: [ {
            field: 'internal_metadata',
            code: 'Invalid',
            message: 'Invalid internal_metadata key: ""'
        } ]
    };
    var listVmsQuery = '/vms?internal_metadata.=foo';

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ok(err,
            'listing VMs using invalid internal_metadata key should error');
        if (err) {
            t.deepEqual(body, expectedError, 'Error should be equal to ' +
                expectedError + ', got: ' + err);
        }

        t.done();
    });
};

exports.list_invalid_empty_metadata_value = function (t) {
    var expectedError = {
        code: 'ValidationFailed',
        message: 'Invalid Parameters',
        errors: [ {
            field: 'internal_metadata',
            code: 'Invalid',
            message: 'Invalid internal_metadata value: ""'
        } ]
    };
    var listVmsQuery = '/vms?internal_metadata.foo=';

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ok(err,
            'listing VMs using invalid internal_metadata value should error');
        if (err) {
            t.deepEqual(body, expectedError, 'Error should be equal to ' +
                expectedError + ', got: ' + err);
        }

        t.done();
    });
};

exports.create_test_vm_records_with_simple_metadata = function (t) {
    vmTest.createTestVMs(1, moray,
        {concurrency: 1, log: testLogger},
        {internal_metadata: {'key': 'foo'}},
            function fakeVmsCreated(err, vmUuids) {
                t.ifError(err, 'Creating test VM should not error');
                t.done();
            });
};

exports.list_valid_simple_internal_metadata = function (t) {
    var listVmsQuery = '/vms?internal_metadata.key=foo';

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata filter should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_simple_internal_metadata_with_predicate = function (t) {
    var listVmsQuery;
    var predicate = JSON.stringify({
        eq: ['internal_metadata.key', 'foo']
    });

    listVmsQuery = '/vms?predicate=' + predicate;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata predicate should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_simple_internal_metadata_with_ldap_query = function (t) {
    var listVmsQuery;
    var query = '(internal_metadata_search_array=key=foo)';

    listVmsQuery = '/vms?query=' + query;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata LDAP query should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.create_test_vm_records_with_dotted_metadata = function (t) {
    vmTest.createTestVMs(1, moray,
        {concurrency: 1, log: testLogger},
        {internal_metadata: {'some.key': 'foo'}},
            function fakeVmsCreated(err, vmUuids) {
                t.ifError(err, 'Creating test VM should not error');
                t.done();
            });
};

exports.list_valid_dotted_internal_metadata = function (t) {
    var listVmsQuery = '/vms?internal_metadata.some.key=foo';

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata filter should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_dotted_internal_metadata_with_predicate = function (t) {
    var listVmsQuery;
    var predicate = JSON.stringify({
        eq: ['internal_metadata.some.key', 'foo']
    });

    listVmsQuery = '/vms?predicate=' + predicate;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata predicate should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_dotted_internal_metadata_with_ldap_query = function (t) {
    var listVmsQuery;
    var query = '(internal_metadata_search_array=some.key=foo)';

    listVmsQuery = '/vms?query=' + query;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata LDAP query should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.create_test_vm_records_with_namespaced_metadata = function (t) {
    vmTest.createTestVMs(1, moray,
        {concurrency: 1, log: testLogger},
        {internal_metadata: {'some:key': 'foo'}},
            function fakeVmsCreated(err, vmUuids) {
                t.ifError(err, 'Creating test VM should not error');
                t.done();
            });
};

exports.list_valid_internal_metadata = function (t) {
    var listVmsQuery = '/vms?internal_metadata.some:key=foo';

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata filter should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_internal_metadata_with_predicate = function (t) {
    var listVmsQuery;
    var predicate = JSON.stringify({
        eq: ['internal_metadata.some:key', 'foo']
    });

    listVmsQuery = '/vms?predicate=' + predicate;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata predicate should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.list_valid_internal_metadata_with_ldap_query = function (t) {
    var listVmsQuery;
    var query = '(internal_metadata_search_array=some:key=foo)';

    listVmsQuery = '/vms?query=' + query;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata LDAP query should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.create_test_vm_records_with_long_metadata_value = function (t) {
    vmTest.createTestVMs(1, moray,
        {concurrency: 1, log: testLogger},
        {internal_metadata: {'some:key': longMetadataValue.toString()}},
            function fakeVmsCreated(err, vmUuids) {
                t.ifError(err, 'Creating test VM should not error');
                t.done();
            });
};

exports.list_long_internal_metadata = function (t) {
    var listVmsQuery;
    var queryMetadataValue = longMetadataValue.toString();

    listVmsQuery = '/vms?internal_metadata.some:key=' + queryMetadataValue;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata filter should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 0, 'Response should not include any VM');
        }

        t.done();
    });
};

exports.list_long_internal_metadata_with_shorter_value = function (t) {
    var clampedMetadataValue = longMetadataValue.slice(0, 100).toString();
    var listVmsQuery = '/vms?internal_metadata.some:key=' +
        clampedMetadataValue;

    client.get(listVmsQuery, function onListVms(err, req, res, body) {
        t.ifError(err,
            'Listing VMs using valid internal_metadata filter should not ' +
                'error');
        t.ok(body, 'response should not be empty');
        if (body) {
            t.equal(body.length, 1, 'Response should include just one VM');
        }

        t.done();
    });
};

exports.cleanup_test_vms = function (t) {
    vmTest.deleteTestVMs(moray, {}, function onTestVmsDeleted(delTestVmsErr) {
        t.ifError(delTestVmsErr, 'Deleting test VMs should not error');
        t.done();
    });
};