arangorb 1.4.1 → 2.0.0

data/spec/lib/0.1.0/arangoDoc_helper.rb

@@ -1,79 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoDocument do
-  context "#new" do
-    it "create a new Document instance without global" do
-      myDocument = ArangoDocument.new collection: "MyCollection", database: "MyDatabase"
-      expect(myDocument.collection.name).to eq "MyCollection"
-    end
-
-    it "create a new instance with global" do
-      myDocument = ArangoDocument.new key: "myKey", body: {"Hello" => "World"}
-      expect(myDocument.key).to eq "myKey"
-    end
-
-    it "create a new Edge instance" do
-      a = ArangoDocument.new(key: "myA", body: {"Hello" => "World"}).create
-      b = ArangoDocument.new(key: "myB", body: {"Hello" => "World"}).create
-      myEdgeDocument = ArangoDocument.new collection: "MyEdgeCollection", from: a, to: b
-      expect(myEdgeDocument.body["_from"]).to eq a.id
-    end
-  end
-
-  context "#create" do
-    it "create a new Document" do
-      @myDocument.destroy
-      myDocument = @myDocument.create
-      expect(myDocument.body["Hello"]).to eq "World"
-    end
-
-    it "create a duplicate Document" do
-      myDocument = @myDocument.create
-      expect(myDocument).to eq "cannot create document, unique constraint violated"
-    end
-
-    it "create a new Edge" do
-      myDoc = @myCollection.create_document document: [{"A" => "B", "num" => 1}, {"C" => "D", "num" => 3}]
-      myEdge = ArangoDocument.new collection: "MyEdgeCollection", from: myDoc[0].id, to: myDoc[1].id
-      myEdge = myEdge.create
-      expect(myEdge.body["_from"]).to eq myDoc[0].id
-    end
-  end
-
-  context "#info" do
-    it "retrieve Document" do
-      myDocument = @myDocument.retrieve
-      expect(myDocument.body["Hello"]).to eq "World"
-    end
-
-    it "retrieve Edges" do
-      @myEdgeCollection.create_edge from: ["MyCollection/myA", "MyCollection/myB"], to: @myDocument
-      myEdges = @myDocument.retrieve_edges(collection: @myEdgeCollection)
-      expect(myEdges.length).to eq 2
-    end
-
-    it "going in different directions" do
-      myDocument = @myDocument.in("MyEdgeCollection")[0].from.out(@myEdgeCollection)[0].to
-      expect(myDocument.id).to eq @myDocument.id
-    end
-  end
-
-  context "#modify" do
-    it "replace" do
-      myDocument = @myDocument.replace body: {"value" => 3}
-      expect(myDocument.body["value"]).to eq 3
-    end
-
-    it "update" do
-      myDocument = @myDocument.update body: {"time" => 13}
-      expect(myDocument.body["value"]).to eq 3
-    end
-  end
-
-  context "#destroy" do
-    it "delete a Document" do
-      result = @myDocument.destroy
-      expect(result).to eq true
-    end
-  end
-end

data/spec/lib/0.1.0/arangoE_helper.rb

@@ -1,50 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoEdge do
-  context "#new" do
-    it "create a new Edge instance" do
-      a = ArangoVertex.new(key: "myA", body: {"Hello" => "World"}).create
-      b = ArangoVertex.new(key: "myB", body: {"Hello" => "World"}).create
-      myEdgeDocument = ArangoEdge.new collection: "MyEdgeCollection", from: a, to: b
-      expect(myEdgeDocument.body["_from"]).to eq a.id
-    end
-  end
-
-  context "#create" do
-    it "create a new Edge" do
-      myDoc = @myCollection.create_document document: [{"A" => "B", "num" => 1}, {"C" => "D", "num" => 3}]
-      myEdge = ArangoEdge.new from: myDoc[0].id, to: myDoc[1].id, collection: "MyEdgeCollection"
-      myEdge = myEdge.create
-      expect(myEdge.body["_from"]).to eq myDoc[0].id
-    end
-  end
-
-  context "#info" do
-    it "retrieve Document" do
-      myDocument = @myEdge.retrieve
-      expect(myDocument.collection.name).to eq "MyEdgeCollection"
-    end
-  end
-
-  context "#modify" do
-    it "replace" do
-      a = ArangoVertex.new(body: {"Hello" => "World"}).create
-      b = ArangoVertex.new(body: {"Hello" => "World!!"}).create
-      myDocument = @myEdge.replace body: {"_from" => a.id, "_to" => b.id}
-      expect(myDocument.body["_from"]).to eq a.id
-    end
-
-    it "update" do
-      cc = ArangoVertex.new(body: {"Hello" => "World!!!"}).create
-      myDocument = @myEdge.update body: {"_to" => cc.id}
-      expect(myDocument.body["_to"]).to eq cc.id
-    end
-  end
-
-  context "#destroy" do
-    it "delete a Document" do
-      result = @myEdge.destroy
-      expect(result).to eq true
-    end
-  end
-end

data/spec/lib/0.1.0/arangoG_helper.rb

@@ -1,78 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoGraph do
-  context "#new" do
-    it "create a new Graph instance without global" do
-      myGraph = ArangoGraph.new graph: "MyGraph", database: "MyDatabase"
-      expect(myGraph.graph).to eq "MyGraph"
-    end
-
-    it "create a new instance with global" do
-      myGraph = ArangoGraph.new
-      expect(myGraph.graph).to eq "MyGraph"
-    end
-  end
-
-  context "#create" do
-    it "create new graph" do
-      @myGraph.destroy
-      myGraph = @myGraph.create
-      expect(myGraph.graph).to eq "MyGraph"
-    end
-  end
-
-  context "#info" do
-    it "info graph" do
-      myGraph = @myGraph.retrieve
-      expect(myGraph.graph).to eq "MyGraph"
-    end
-  end
-
-  context "#manageVertexCollections" do
-    it "add VertexCollection" do
-      @myGraph.removeEdgeCollection collection: "MyEdgeCollection"
-      @myGraph.removeVertexCollection collection: "MyCollection"
-      myGraph = @myGraph.addVertexCollection collection: "MyCollection"
-      expect(myGraph.orphanCollections[0]).to eq "MyCollection"
-    end
-
-    it "retrieve VertexCollection" do
-      myGraph = @myGraph.vertexCollections
-      expect(myGraph[0].collection).to eq "MyCollection"
-    end
-
-    it "remove VertexCollection" do
-      myGraph = @myGraph.removeVertexCollection collection: "MyCollection"
-      expect(myGraph.orphanCollections[0]).to eq nil
-    end
-  end
-
-  context "#manageEdgeCollections" do
-    it "add EdgeCollection" do
-      myGraph = @myGraph.addEdgeCollection collection: "MyEdgeCollection", from: "MyCollection", to: @myCollectionB
-      expect(myGraph.edgeDefinitions[0]["from"][0]).to eq "MyCollection"
-    end
-
-    it "retrieve EdgeCollection" do
-      myGraph = @myGraph.edgeCollections
-      expect(myGraph[0].collection).to eq "MyEdgeCollection"
-    end
-
-    it "replace EdgeCollection" do
-      myGraph = @myGraph.replaceEdgeCollection collection: @myEdgeCollection, from: "MyCollection", to: "MyCollection"
-      expect(myGraph.edgeDefinitions[0]["to"][0]).to eq "MyCollection"
-    end
-
-    it "remove EdgeCollection" do
-      myGraph = @myGraph.removeEdgeCollection collection: "MyEdgeCollection"
-      expect(myGraph.edgeDefinitions[0]).to eq nil
-    end
-  end
-
-  context "#destroy" do
-    it "delete graph" do
-      myGraph = @myGraph.destroy
-      expect(myGraph).to be true
-    end
-  end
-end

data/spec/lib/0.1.0/arangoS_helper.rb

@@ -1,37 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoServer do
-  context "#database" do
-    it "setup a global database" do
-      ArangoServer.database = "MyDatabase"
-      expect(ArangoServer.database.name).to eq "MyDatabase"
-    end
-  end
-
-  context "#graph" do
-    it "setup a global graph" do
-      ArangoServer.graph = "MyGraph"
-      expect(ArangoServer.graph.name).to eq "MyGraph"
-    end
-  end
-
-  context "#collection" do
-    it "setup a global collection" do
-      ArangoServer.collection = "MyCollection"
-      expect(ArangoServer.collection.name).to eq "MyCollection"
-    end
-  end
-
-  context "#verbose" do
-    it "try verbose" do
-      ArangoServer.verbose = true
-      result = ArangoCollection.new(collection: "Test").create
-      expect(result.class).to be Hash
-    end
-
-    it "print verbose" do
-      ArangoServer.verbose = true
-      expect(ArangoServer.verbose).to be true
-    end
-  end
-end

data/spec/lib/0.1.0/arangoT_helper.rb

@@ -1,48 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoTraversal do
-  context "#new" do
-    it "create a new Traversal instance" do
-      myTraversal = ArangoTraversal.new
-      expect(myTraversal.database.name).to eq "MyDatabase"
-    end
-
-    it "instantiate start Vertex" do
-      @myTraversal.vertex = @myDoc[0]
-      expect(@myTraversal.vertex.id).to eq "MyCollection/FirstKey"
-    end
-
-    it "instantiate Graph" do
-      @myTraversal.graph = @myGraph
-      expect(@myTraversal.graph.name).to eq @myGraph.graph
-    end
-
-    it "instantiate EdgeCollection" do
-      @myTraversal.collection = @myEdgeCollection
-      expect(@myTraversal.collection.name).to eq @myEdgeCollection.collection
-    end
-
-    it "instantiate Direction" do
-      @myTraversal.in
-      expect(@myTraversal.direction).to eq "inbound"
-    end
-
-    it "instantiate Max" do
-      @myTraversal.max = 3
-      expect(@myTraversal.max).to eq 3
-    end
-
-    it "instantiate Min" do
-      @myTraversal.min = 1
-      expect(@myTraversal.min).to eq 1
-    end
-  end
-
-  context "#execute" do
-    it "execute Traversal" do
-      @myTraversal.any
-      @myTraversal.execute
-      expect(@myTraversal.vertices.length).to be >= 30
-    end
-  end
-end

data/spec/lib/0.1.0/arangoV_helper.rb

@@ -1,65 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoVertex do
-  context "#new" do
-    it "create a new Document instance without global" do
-      myVertex = ArangoVertex.new collection: "MyCollection", database: "MyDatabase", graph: "MyGraph"
-      expect(myVertex.collection.name).to eq "MyCollection"
-    end
-
-    it "create a new instance with global" do
-      myVertex = ArangoVertex.new key: "myKey", body: {"Hello" => "World"}
-      expect(myVertex.key).to eq "myKey"
-    end
-  end
-
-  context "#create" do
-    it "create a new Document" do
-      @myVertex.destroy
-      myVertex = @myVertex.create
-      expect(myVertex.body["Hello"]).to eq "World"
-    end
-
-    it "create a duplicate Document" do
-      myVertex = @myVertex.create
-      expect(myVertex).to eq "unique constraint violated"
-    end
-  end
-
-  context "#info" do
-    it "retrieve Document" do
-      myVertex = @myVertex.retrieve
-      expect(myVertex.body["Hello"]).to eq "World"
-    end
-
-    it "retrieve Edges" do
-      @myEdgeCollection.create_edge from: ["MyCollection/myA", "MyCollection/myB"], to: @myVertex
-      myEdges = @myVertex.retrieve_edges(collection: @myEdgeCollection)
-      expect(myEdges.length).to eq 2
-    end
-
-    # it "going in different directions" do
-    #   myVertex = @myVertex.in("MyEdgeCollection")[0].from.out(@myEdgeCollection)[0].to
-    #   expect(myVertex.id).to eq @myVertex.id
-    # end
-  end
-
-  context "#modify" do
-    it "replace" do
-      myVertex = @myVertex.replace body: {"value" => 3}
-      expect(myVertex.body["value"]).to eq 3
-    end
-
-    it "update" do
-      myVertex = @myVertex.update body: {"time" => 13}
-      expect(myVertex.body["value"]).to eq 3
-    end
-  end
-
-  context "#destroy" do
-    it "delete a Document" do
-      result = @myVertex.destroy
-      expect(result).to eq true
-    end
-  end
-end

data/spec/lib/1.0.0/arangoC_helper.rb

@@ -1,73 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoCollection do
-  context "#get" do
-    it "revision" do
-      expect(@myCollection.revision.class).to be String
-    end
-
-    it "collection" do
-      expect(@myCollection.rotate).to eq "could not rotate journal: no journal"
-    end
-  end
-
-  context "#import" do
-    it "import" do
-      attributes = ["value", "num", "name"]
-      values = [["uno",1,"ONE"],["due",2,"TWO"],["tre",3,"THREE"]]
-      result = @myCollection.import attributes: attributes, values: values
-      expect(result["created"]).to eq 3
-    end
-
-    it "import single" do
-      attributes = ["value", "num", "name"]
-      values = ["uno",1,"ONE"]
-      result = @myCollection.import attributes: attributes, values: values
-      expect(result["created"]).to eq 1
-    end
-
-    it "importJSON" do
-      body = [{"value": "uno", "num": 1, "name": "ONE"}, {"value": "due", "num": 2, "name": "DUE"}]
-      result = @myCollection.importJSON body: body
-      expect(result["created"]).to eq 2
-    end
-  end
-
-  context "#export" do
-    it "export" do
-      result = @myCollection.export flush: true
-      expect(result[0].class).to be ArangoDocument
-    end
-
-    it "exportNext" do
-      result = @myCollection.export batchSize: 3, flush: true
-      result = @myCollection.exportNext
-      expect(result[0].class).to be ArangoDocument
-    end
-  end
-
-  context "#indexes" do
-    it "indexes" do
-      expect(@myCollection.indexes["indexes"][0].class).to be ArangoIndex
-    end
-    #
-    # it "retrieve" do
-    #   expect((@myCollection.retrieveIndex id: 0).unique).to be true
-    # end
-    #
-    it "create" do
-      myIndex = @myCollection.createIndex unique: false, fields: "num", type: "hash"
-      expect(myIndex.fields).to eq ["num"]
-    end
-    #
-    # it "delete" do
-    #   expect(@myCollection.deleteIndex id: @myIndex.key).to eq true
-    # end
-  end
-
-  context "#replication" do
-    it "data" do
-      expect(@myCollection.data.length).to be > 100
-    end
-  end
-end

data/spec/lib/1.0.0/arangoDB_helper.rb

@@ -1,48 +0,0 @@
-require_relative './../../spec_helper'
-
-describe ArangoDatabase do
-  context "#replication" do
-    it "inventory" do
-      expect(@myDatabase.inventory["collections"].class).to be Array
-    end
-
-    it "clusterInventory" do
-      expect(@myDatabase.clusterInventory).to eq "this operation is only valid on a coordinator in a cluster"
-    end
-
-    # it "logger" do
-    #   expect(@myDatabase.logger["state"]["running"]).to be true
-    # end
-
-    # it "lastLogger" do
-    #   expect(@myDatabase.loggerFollow.class).to be String
-    # end
-
-    # it "fistTick" do
-    #   expect(@myDatabase.firstTick.to_i).to be >= 1
-    # end
-
-    # it "rangeTick" do
-    #   expect(@myDatabase.rangeTick[0]["datafile"].class).to be String
-    # end
-
-    # it "configurationReplication" do
-    #   expect(@myDatabase.configurationReplication["requestTimeout"]).to eq 600
-    # end
-
-    # it "modifyConfigurationReplication" do
-    #   result = @myDatabase.modifyConfigurationReplication autoStart: true
-    #   expect(result["autoStart"]).to be true
-    # end
-  end
-
-  context "#user" do
-    it "grant" do
-      expect(@myDatabase.grant user: @myUser).to be true
-    end
-
-    it "revoke" do
-      expect(@myDatabase.revoke user: @myUser).to be true
-    end
-  end
-end