gcloud 0.1.0 → 0.1.1

data/test/gcloud/datastore/test_entity.rb

@@ -1,161 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require "helper"
-require "gcloud/datastore"
-
-describe Gcloud::Datastore::Entity do
-
-  let(:entity) do
-    Gcloud::Datastore::Entity.new.tap do |ent|
-      ent.key = Gcloud::Datastore::Key.new "User", "username"
-      ent["name"] = "User McUser"
-      ent["email"] = "user@example.net"
-    end
-  end
-
-  it "creates instances with .new" do
-    # Calling entity here creates by calling new
-    entity.wont_be :nil?
-    entity.properties["name"].must_equal "User McUser"
-    entity.properties["email"].must_equal "user@example.net"
-  end
-
-  it "returns a correct protocol buffer object" do
-    proto = entity.to_proto
-
-    # Key values
-    proto.key.path_element.count.must_equal 1
-    proto.key.path_element.last.kind.must_equal "User"
-    proto.key.path_element.last.id.must_be :nil?
-    proto.key.path_element.last.name.must_equal "username"
-
-    # Property values
-    proto.property.count.must_equal 2
-    proto.property.find { |p| p.name == "name" }.value.string_value.must_equal entity["name"]
-    proto.property.find { |p| p.name == "email" }.value.string_value.must_equal entity["email"]
-  end
-
-  it "can be created with a protocol buffer object" do
-    proto = Gcloud::Datastore::Proto::Entity.new
-    proto.key = Gcloud::Datastore::Proto::Key.new
-    proto.key.path_element = [Gcloud::Datastore::Proto::Key::PathElement.new]
-    proto.key.path_element.first.kind = "User"
-    proto.key.path_element.first.id = 123456
-    proto.property = [Gcloud::Datastore::Proto::Property.new,
-                      Gcloud::Datastore::Proto::Property.new]
-    proto.property.first.name = "name"
-    proto.property.first.value = Gcloud::Datastore::Proto.to_proto_value "User McNumber"
-    proto.property.last.name = "email"
-    proto.property.last.value = Gcloud::Datastore::Proto.to_proto_value "number@example.net"
-
-    entity_from_proto = Gcloud::Datastore::Entity.from_proto proto
-
-    entity_from_proto.key.kind.must_equal "User"
-    entity_from_proto.key.id.must_equal 123456
-    entity_from_proto.key.name.must_be :nil?
-    entity_from_proto.properties["name"].must_equal "User McNumber"
-    entity_from_proto.properties["email"].must_equal "number@example.net"
-  end
-
-  it "can store other entities as properties" do
-    task1 = Gcloud::Datastore::Entity.new.tap do |t|
-      t.key = Gcloud::Datastore::Key.new "Task", 1111
-      t["description"] = "can persist entities"
-      t["completed"] = true
-    end
-    task2 = Gcloud::Datastore::Entity.new.tap do |t|
-      t.key = Gcloud::Datastore::Key.new "Task", 2222
-      t["description"] = "can persist lists"
-      t["completed"] = true
-    end
-    entity["tasks"] = [task1, task2]
-
-    proto = entity.to_proto
-
-    task_property = proto.property.last
-    task_property.name.must_equal "tasks"
-    task_property.value.list_value.wont_be :nil?
-    task_property.value.list_value.count.must_equal 2
-    proto_task_1 = task_property.value.list_value.first
-    proto_task_2 = task_property.value.list_value.last
-    proto_task_1.wont_be :nil?
-    proto_task_2.wont_be :nil?
-    proto_task_1.entity_value.wont_be :nil?
-    proto_task_2.entity_value.wont_be :nil?
-    proto_task_1.entity_value.property.find { |p| p.name == "description" }.value.string_value.must_equal "can persist entities"
-    proto_task_2.entity_value.property.find { |p| p.name == "description" }.value.string_value.must_equal "can persist lists"
-  end
-
-  it "can store keys as properties" do
-    list = Gcloud::Datastore::Entity.new.tap do |t|
-      t.key = Gcloud::Datastore::Key.new "List", 1111
-      t["description"] = "can persist keys"
-    end
-    key1 = Gcloud::Datastore::Key.new "Task", 1111
-
-    list["head"] = key1
-
-    # Do this multiple times to make sure the call to Key.from_proto
-    # isn't modifying the original key stored in the entity's property.
-    5.times do
-      assert_equal key1.path, list["head"].path
-    end
-
-    proto = list.to_proto
-
-    key_property = proto.property.last
-    key_property.name.must_equal "head"
-
-    key_value = key_property.value.key_value
-    key_value.wont_be :nil?
-    key_value.path_element.first.kind.must_equal key1.kind
-    key_value.path_element.first.name.must_equal key1.name
-    key_value.path_element.first.id.must_equal   key1.id
-  end
-
-  it "raises when setting an unsupported property type" do
-    error = assert_raises Gcloud::Datastore::PropertyError do
-      entity["thing"] = OpenStruct.new
-    end
-    error.message.must_equal "A property of type OpenStruct is not supported."
-  end
-
-  it "raises when setting a key when persisted" do
-    proto = Gcloud::Datastore::Proto::Entity.new
-    proto.key = Gcloud::Datastore::Proto::Key.new
-    proto.key.path_element = [Gcloud::Datastore::Proto::Key::PathElement.new]
-    proto.key.path_element.first.kind = "User"
-    proto.key.path_element.first.id = 123456
-    proto.property = [Gcloud::Datastore::Proto::Property.new,
-                      Gcloud::Datastore::Proto::Property.new]
-    proto.property.first.name = "name"
-    proto.property.first.value = Gcloud::Datastore::Proto.to_proto_value "User McNumber"
-    proto.property.last.name = "email"
-    proto.property.last.value = Gcloud::Datastore::Proto.to_proto_value "number@example.net"
-
-    entity_from_proto = Gcloud::Datastore::Entity.from_proto proto
-
-    entity_from_proto.must_be :persisted?
-    entity_from_proto.key.must_be :frozen?
-
-    assert_raises RuntimeError do
-      entity_from_proto.key = Gcloud::Datastore::Key.new "User", 456789
-    end
-
-    assert_raises RuntimeError do
-      entity_from_proto.key.id = 456789
-    end
-  end
-end

data/test/gcloud/datastore/test_entity_exclude.rb

@@ -1,225 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require "helper"
-require "gcloud/datastore"
-
-describe Gcloud::Datastore::Entity, :exclude_from_indexes do
-
-  let(:entity) do
-    Gcloud::Datastore::Entity.new.tap do |ent|
-      ent.key = Gcloud::Datastore::Key.new "User", "username"
-      ent["name"] = "User McUser"
-      ent["email"] = "user@example.net"
-    end
-  end
-
-  it "doesn't exclude from indexes by default" do
-    refute entity.exclude_from_indexes?("name")
-    refute entity.exclude_from_indexes?("email")
-
-    proto = entity.to_proto
-
-    assert proto.property.find { |p| p.name == "name"  }.value.indexed.must_equal true
-    assert proto.property.find { |p| p.name == "email" }.value.indexed.must_equal true
-  end
-
-  it "excludes when setting a boolean" do
-    entity["age"] = 21
-    entity.exclude_from_indexes! "age", true
-
-    entity.exclude_from_indexes?("age").must_equal true
-
-    proto = entity.to_proto
-
-    proto.property.find { |p| p.name == "age"  }.value.indexed.must_equal false
-  end
-
-  it "excludes when setting a Proc" do
-    entity["age"] = 21
-    entity.exclude_from_indexes! "age" do |age|
-      age > 18
-    end
-
-    entity.exclude_from_indexes?("age").must_equal true
-
-    proto = entity.to_proto
-
-    proto.property.find { |p| p.name == "age"  }.value.indexed.must_equal false
-
-    # And now the inverse, the Proc evaluates to false
-
-    entity.exclude_from_indexes! "age" do |age|
-      age < 18
-    end
-
-    entity.exclude_from_indexes?("age").must_equal false
-
-    proto = entity.to_proto
-
-    proto.property.find { |p| p.name == "age"  }.value.indexed.must_equal true
-  end
-
-  it "excludes when setting an Array on a non array value" do
-    entity["age"] = 21
-    entity.exclude_from_indexes! "age", [true, false, true, false]
-
-    entity.exclude_from_indexes?("age").must_equal true
-
-    proto = entity.to_proto
-
-    proto.property.find { |p| p.name == "age"  }.value.indexed.must_equal false
-
-    # And now the inverse, the first value is false
-
-    entity.exclude_from_indexes! "age", [false, true, false, true]
-
-    entity.exclude_from_indexes?("age").must_equal false
-
-    proto = entity.to_proto
-
-    proto.property.find { |p| p.name == "age"  }.value.indexed.must_equal true
-  end
-
-  describe Array do
-    it "doesn't exclude Array values from indexes by default" do
-      entity["tags"] = ["ruby", "code"]
-
-      entity.exclude_from_indexes?("tags").must_equal [false, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [true, true]
-    end
-
-    it "excludes an Array when setting a boolean" do
-      entity["tags"] = ["ruby", "code"]
-      entity.exclude_from_indexes! "tags", true
-
-      entity.exclude_from_indexes?("tags").must_equal [true, true]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, false]
-    end
-
-    it "excludes an Array when setting a Proc" do
-      entity["tags"] = ["ruby", "code"]
-      entity.exclude_from_indexes! "tags" do |tag|
-        tag =~ /r/
-      end
-
-      entity.exclude_from_indexes?("tags").must_equal [true, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, true]
-
-      # And now the inverse, the Proc evaluates to false
-
-      entity["tags"] = ["ruby", "code"]
-      entity.exclude_from_indexes! "tags" do |tag|
-        tag =~ /c/
-      end
-
-      entity.exclude_from_indexes?("tags").must_equal [false, true]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [true, false]
-    end
-
-    it "excludes an Array when setting an Array" do
-      entity["tags"] = ["ruby", "code"]
-      entity.exclude_from_indexes! "tags", [true, false]
-
-      entity.exclude_from_indexes?("tags").must_equal [true, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, true]
-    end
-
-    it "excludes an Array when setting an Array that is too small" do
-      entity["tags"] = ["ruby", "code", "google", "cloud"]
-      entity.exclude_from_indexes! "tags", [true, false]
-
-      # the default is to not exclude when the array is too small
-      entity.exclude_from_indexes?("tags").must_equal [true, false, false, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, true, true, true]
-    end
-
-    it "excludes an Array when setting an Array that is too big" do
-      entity["tags"] = ["ruby", "code"]
-      entity.exclude_from_indexes! "tags", [true, false, true, false, true, false]
-
-      entity.exclude_from_indexes?("tags").must_equal [true, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, true]
-
-      # Now add to the entity and get the previously stored exclude values
-
-      entity["tags"] = ["ruby", "code", "google", "cloud"]
-
-      entity.exclude_from_indexes?("tags").must_equal [true, false, true, false]
-
-      proto = entity.to_proto
-
-      tag_proto = proto.property.find { |p| p.name == "tags"  }.value
-      tag_proto.indexed.must_be :nil? # list values must always be unset
-      tag_proto.list_value.map { |value| value.indexed }.must_equal [false, true, false, true]
-    end
-  end
-
-  describe "Edge Cases" do
-    it "recalculates when changing from a single value to an array" do
-      entity["tags"] = "ruby"
-
-      entity.exclude_from_indexes?("tags").must_equal false
-
-      entity.exclude_from_indexes! "tags", true
-
-      entity.exclude_from_indexes?("tags").must_equal true
-
-      entity["tags"] = ["ruby", "code"]
-
-      entity.exclude_from_indexes?("tags").must_equal [true, true]
-
-      entity.exclude_from_indexes! "tags", [false, false]
-
-      entity["tags"] = "ruby"
-
-      entity.exclude_from_indexes?("tags").must_equal false
-    end
-  end
-end

data/test/gcloud/datastore/test_key.rb

@@ -1,189 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require "helper"
-require "gcloud/datastore"
-
-describe Gcloud::Datastore::Key do
-
-  it "behaves correctly when empty" do
-    key = Gcloud::Datastore::Key.new
-    key.kind.must_be :nil?
-    key.id.must_be :nil?
-    key.name.must_be :nil?
-    key.dataset_id.must_be :nil?
-    key.namespace.must_be :nil?
-  end
-
-  it "creates instances with .new" do
-    key = Gcloud::Datastore::Key.new "ThisThing", 1234
-    key.kind.must_equal "ThisThing"
-    key.id.must_equal 1234
-    key.name.must_be :nil?
-
-    key = Gcloud::Datastore::Key.new "ThisThing", "charlie"
-    key.kind.must_equal "ThisThing"
-    key.id.must_be :nil?
-    key.name.must_equal "charlie"
-  end
-
-  it "can set a parent" do
-    key = Gcloud::Datastore::Key.new "ThisThing", 1234
-    key.kind.must_equal "ThisThing"
-    key.id.must_equal 1234
-    key.name.must_be :nil?
-
-    key.parent.must_be :nil?
-    key.parent = Gcloud::Datastore::Key.new "ThatThing", 6789
-    key.parent.wont_be :nil?
-    key.parent.kind.must_equal "ThatThing"
-    key.parent.id.must_equal 6789
-    key.parent.name.must_be :nil?
-  end
-
-  it "can set a dataset_id" do
-    key = Gcloud::Datastore::Key.new "ThisThing", 1234
-    key.kind.must_equal "ThisThing"
-    key.id.must_equal 1234
-    key.name.must_be :nil?
-
-    key.dataset_id.must_be :nil?
-    key.dataset_id = "custom-ds"
-    key.dataset_id.wont_be :nil?
-    key.dataset_id.must_equal "custom-ds"
-  end
-
-  it "can set a namespace" do
-    key = Gcloud::Datastore::Key.new "ThisThing", 1234
-    key.kind.must_equal "ThisThing"
-    key.id.must_equal 1234
-    key.name.must_be :nil?
-
-    key.namespace.must_be :nil?
-    key.namespace = "custom-ns"
-    key.namespace.wont_be :nil?
-    key.namespace.must_equal "custom-ns"
-  end
-
-  describe "path" do
-    it "returns kind and id" do
-      key = Gcloud::Datastore::Key.new "Task", 123456
-      key.path.must_equal [["Task", 123456]]
-    end
-    it "returns kind and name" do
-      key = Gcloud::Datastore::Key.new "Task", "todos"
-      key.path.must_equal [["Task", "todos"]]
-    end
-    it "returns parent when present" do
-      key = Gcloud::Datastore::Key.new "Task", "todos"
-      key.parent = Gcloud::Datastore::Key.new "User", "username"
-      key.path.must_equal [["User", "username"], ["Task", "todos"]]
-    end
-    it "returns all parents when present" do
-      key = Gcloud::Datastore::Key.new "Task", "todos"
-      key.parent = Gcloud::Datastore::Key.new "User", "username"
-      key.parent.parent = Gcloud::Datastore::Key.new "Org", "company"
-      key.path.must_equal [["Org", "company"], ["User", "username"], ["Task", "todos"]]
-    end
-  end
-
-  it "knows if it is complete or not" do
-    key = Gcloud::Datastore::Key.new "Task"
-    key.id.must_be :nil?
-    key.name.must_be :nil?
-    key.wont_be :complete?
-    key.must_be :incomplete?
-
-    key.id = 123455
-    key.id.wont_be :nil?
-    key.name.must_be :nil?
-    key.must_be :complete?
-    key.wont_be :incomplete?
-
-    key.name = "description"
-    key.id.must_be :nil?
-    key.name.wont_be :nil?
-    key.must_be :complete?
-    key.wont_be :incomplete?
-  end
-
-  it "isn't complete is missing kind" do
-    key = Gcloud::Datastore::Key.new "Task"
-    key.kind = nil
-    key.kind.must_be :nil?
-    key.id.must_be :nil?
-    key.name.must_be :nil?
-    key.wont_be :complete?
-    key.must_be :incomplete?
-
-    key.id = 123455
-    key.kind.must_be :nil?
-    key.id.wont_be :nil?
-    key.name.must_be :nil?
-    key.wont_be :complete?
-    key.must_be :incomplete?
-
-    key.name = "description"
-    key.kind.must_be :nil?
-    key.id.must_be :nil?
-    key.name.wont_be :nil?
-    key.wont_be :complete?
-    key.must_be :incomplete?
-  end
-
-  it "returns a correct protocol buffer object" do
-    key = Gcloud::Datastore::Key.new "ThisThing", 1234
-    proto = key.to_proto
-    proto.path_element.count.must_equal 1
-    proto.path_element.last.kind.must_equal "ThisThing"
-    proto.path_element.last.id.must_equal 1234
-    proto.path_element.last.name.must_be :nil?
-    proto.partition_id.dataset_id.must_be :nil?
-    proto.partition_id.namespace.must_be :nil?
-
-    key = Gcloud::Datastore::Key.new "ThisThing", "charlie"
-    key.parent = Gcloud::Datastore::Key.new "ThatThing", "henry"
-    key.dataset_id = "custom-ds"
-    key.namespace = "custom-ns"
-    proto = key.to_proto
-    proto.path_element.count.must_equal 2
-    proto.path_element.first.kind.must_equal "ThatThing"
-    proto.path_element.first.id.must_be :nil?
-    proto.path_element.first.name.must_equal "henry"
-    proto.path_element.last.kind.must_equal "ThisThing"
-    proto.path_element.last.id.must_be :nil?
-    proto.path_element.last.name.must_equal "charlie"
-    proto.partition_id.dataset_id.must_equal "custom-ds"
-    proto.partition_id.namespace.must_equal "custom-ns"
-  end
-
-  it "can be created with a protocol buffer object" do
-    proto = Gcloud::Datastore::Proto::Key.new
-    proto.path_element = [Gcloud::Datastore::Proto::Key::PathElement.new]
-    proto.path_element.first.kind = "AnotherThing"
-    proto.path_element.first.id = 56789
-    proto.partition_id = Gcloud::Datastore::Proto::PartitionId.new
-    proto.partition_id.dataset_id = "custom-ds"
-    proto.partition_id.namespace = "custom-ns"
-    key = Gcloud::Datastore::Key.from_proto proto
-
-    key.wont_be :nil?
-    key.kind.must_equal "AnotherThing"
-    key.id.must_equal 56789
-    key.name.must_be :nil?
-    key.dataset_id.must_equal "custom-ds"
-    key.namespace.must_equal "custom-ns"
-    key.must_be :frozen?
-  end
-end