import { AbstractDataStore } from "./AbstractDataStore";
import assert = require("assert");
import { IOperation } from "..";

/*************************************************************************
 *
 * Troven CONFIDENTIAL
 * __________________
 *
 *  (c) 2017-2020 Troven Ventures Pty Ltd
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Troven Pty Ltd and its licensors,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Troven Pty Ltd
 * and its suppliers and may be covered by International and Regional Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Troven Pty Ltd.
 */

export class MockDataStore extends AbstractDataStore {
    name: "mock";

    healthy(options: any, callback: Function): void {
        assert(callback, "missing callback");
        assert(options, "missing options");
        callback(null, {
            now: Date.now,
            errors: false,
        });
    }

    query(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    create(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    read(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    list(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    aggregate(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    update(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    delete(op: IOperation, options: any, callback: Function): void {
        assert(op, "missing operation");
        assert(options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
    bulk(
        op: IOperation,
        delete_first: boolean,
        items: any[],
        req_options: any,
        callback: Function
    ): void {
        assert(op, "missing operation");
        assert(delete_first, "missing delete_first");
        assert(items, "missing items");
        assert(req_options, "missing options");
        assert(callback, "missing callback");
        throw new Error("Method not implemented.");
    }
}