Assert = require "assert"
Dynoga = require "../lib/dynoga"

# Configuration
db = new Dynoga
  endpoint: "http://localhost:8000"
  accessKeyId: process.env.METIDIA_ACCESS_KEY_ID
  secretAccessKey: process.env.METIDIA_SECRET_ACCESS_KEY
  region: "eu-west-1"

describe "dynoga", () ->
  beforeEach (done) ->
    # Delete table
    db.dynamo.deleteTable
      TableName: "dynoga-test"
      (deleteErr, data) ->
        # Create table
        db.dynamo.createTable
          TableName: "dynoga-test"
          AttributeDefinitions: [
            {
              AttributeName: "userID"
              AttributeType: "S"
            },{
              AttributeName: "id"
              AttributeType: "S"
            }
          ]
          KeySchema: [
            {
              AttributeName: "userID"
              KeyType: "HASH"
            }, {
              AttributeName: "id"
              KeyType: "RANGE"
            }
          ]
          ProvisionedThroughput:
            ReadCapacityUnits: 10
            WriteCapacityUnits: 10
          done

  describe "create", () ->
    it "should create a new insert in bdd", (done) ->
      input =
        id: "1"
        userID: "test"
        age: 50
        sexualSlaves: ["poney", "barby", "Mr slave", "bibou"]

      db.create "dynoga-test", input, (err, data) ->
        if err then console.log err
        Assert.deepEqual data, input
        do done

    it "should generate an id", (done) ->
      db.create "dynoga-test", {userID: "test"}, (err, data) ->
        if err then console.log err
        Assert.equal typeof data.id, "string"
        do done

    it "should ignore empty string", (done) ->
      input =
        id: "1"
        userID: "test"
        age: 20
        optional: ""

      db.create "dynoga-test", input, (err, data) ->
        if err then console.log err
        delete input.optional
        Assert.deepEqual data, input
        do done

  describe "read", () ->
    it "should return same object as saved", (done) ->
      input =
        id: "1"
        userID: "test"
        age: 50
        sexualSlaves: ["poney", "barby", "Mr slave", "bibou"]

      db.create "dynoga-test", input, (err, createData) ->
        db.read "dynoga-test", {id: "1", userID: "test"}, (err, readData) ->
          if err then console.log err
          delete input._createTimeStamp
          Assert.deepEqual readData, input
          do done

    it "should return the collection", (done) ->
      expected = [
        {id: "2", userID: "test"}
        {id: "1", userID: "test"}
        {id: "3", userID: "test"}
        {id: "4", userID: "test"}
        {id: "5", userID: "test"}
      ]

      db.create "dynoga-test", {id: "2", userID: "test"}, (err, data) ->
        db.create "dynoga-test", {id: "1", userID: "test"}, (err, data) ->
          db.create "dynoga-test", {id: "3", userID: "test"}, (err, data) ->
            db.create "dynoga-test", {id: "4", userID: "test"}, (err, data) ->
              db.create "dynoga-test", {id: "5", userID: "test"}, (err, data) ->
                db.read "dynoga-test", {userID: "test"}, (err, collection) ->
                  Assert.deepEqual collection, expected
                  do done

  describe "update", () ->
    it "should return the updated object", (done) ->
      input =
        id: "1"
        userID: "test"
        age: 50
        sexualSlaves: ["poney", "barby", "Mr slave", "bibou"]

      expected =
        id: "1"
        userID: "test"
        age: 40
        sexualSlaves: ["poney", "barby", "Mr slave", "bibou"]

      db.create "dynoga-test", input, (err, createData) ->
        db.update "dynoga-test", {id: "1", userID: "test", age: 40}, (err, updatedata) ->
          if err then console.log err
          Assert.deepEqual updatedata, expected
          do done


  describe "delete", () ->
    it "should return deleted object and delete it", (done) ->
      input =
        id: "1"
        userID: "test"
        age: 50
        sexualSlaves: ["poney", "barby", "Mr slave", "bibou"]

      db.create "dynoga-test", input, (err, createData) ->
        db.delete "dynoga-test", {id: "1", userID: "test"}, (err, deleteData) ->
          delete input._createTimeStamp
          Assert.deepEqual deleteData, input
          db.read "dynoga-test", {id: "1", userID: "test"}, (err, readData) ->
            Assert.strictEqual readData, undefined
            do done