usergrid_iron 0.0.1

data/spec/spec_settings.yaml

@@ -0,0 +1,12 @@
+:api_url: http://localhost:8080
+:management:
+  :username: test
+  :password: test
+:organization:
+  :name: test-organization
+  :username: test
+  :password: test
+:application:
+  :name: test-app
+  :username: test-app-user
+  :password: test

data/spec/usergrid/core/application_spec.rb

@@ -0,0 +1,271 @@
+describe Usergrid::Application do
+
+  before :all do
+    @application = create_random_application
+    @user = create_random_user @application, true
+  end
+
+  after :all do
+    @user.delete
+    delete_application @application
+  end
+
+  it "should be able to create and delete a user" do
+    random = SecureRandom.hex
+    response = @application.create_user("username_#{random}", "#{random} name", "#{random}@email.com", random)
+    entity = response.entity
+    begin
+      response.code.should eq 200
+      response.entities.size.should eq 1
+      entity.uuid.should_not be_nil
+      response = @application["users/#{entity.uuid}"].get
+      response.code.should eq 200
+    ensure
+      entity.delete
+      expect { @application["users/#{entity.uuid}"].get }.to raise_error(RestClient::ResourceNotFound)
+    end
+  end
+
+  it "should be able to retrieve users" do
+    entity1 = create_random_user @application
+    entity2 = create_random_user @application
+    begin
+      response = @application.users
+      response.entities.size.should be >= 2
+      match1 = match2 = false
+      response.entities.each do |e|
+        match1 ||= e.username == entity1.username
+        match2 ||= e.username == entity2.username
+      end
+      match1.should be_true
+      match2.should be_true
+    ensure
+      entity1.delete
+      entity2.delete
+    end
+    response = @application.users
+    response.code.should eq 200
+    response.entities.should be_an Array
+  end
+
+  it "should be able to query users" do
+    entity1 = create_random_user @application
+    entity2 = create_random_user @application
+    begin
+      response = @application.users "select * where username = \'#{entity1.username}\'"
+      response.entities.size.should eq 1
+      response.entity.username.should eq entity1.username
+    ensure
+      entity1.delete
+      entity2.delete
+    end
+  end
+
+  it "should be able to update a user" do
+    entity = create_random_user @application
+    begin
+      updates = { email: 'testuser6@email.com', city: 'santa clarita' }
+      response = @application.put updates
+      updates.each {|k,v| response.entity[k.to_s].should eq v }
+    ensure
+      entity.delete
+    end
+  end
+
+  it "should be able to retrieve the logged in user" do
+    user = @application.current_user
+    user.uuid.should_not be_nil
+  end
+
+  it "should be able to add and retrieve activities" do
+    user = @application.current_user
+    activity = {
+        verb: "post",
+        content: "testy, testy",
+        actor: {
+          uuid: user.uuid,
+          email: user.email,
+          username: user.username,
+          displayName: user.username,
+          image: {
+            height: 80,
+            width: 80,
+            url: user.picture
+          }}}
+    response = @application['activities'].post activity
+    activity_path = response.entity['metadata']['path']
+    response.code.should eq 200
+
+    begin
+      entity = @application.activities.entity
+      activity.add_dot_notation!
+      entity.verb.should eq activity.verb
+      entity.content.should eq activity.content
+      entity.actor.uuid.should eq activity.actor.uuid
+    ensure
+      @application[activity_path].delete
+    end
+  end
+
+  it "should be able to retrieve a user's feed" do
+    response = @application.current_user.resource['feed'].get
+    response.code.should eq 200
+    response.entities.should be_an Array
+  end
+
+  it "should be able to follow a user" do
+    follower = create_random_user @application
+    begin
+      me = @application.current_user
+      @application["users/#{follower.uuid}/following/users/#{me.uuid}"].post "{}"
+
+      response = @application["users/#{follower.uuid}/following"].get
+      response.entities.size.should == 1
+      response.entity.uuid.should eq me.uuid
+
+      response = @application.current_user.resource['followers'].get
+      response.entities.size.should be > 0
+    ensure
+      follower.delete
+    end
+  end
+
+  it "should be able to create and retrieve groups" do
+    response = @application.groups
+    size = response.entities.size
+    random = SecureRandom.hex
+    @application.create_entity :groups, path: "test-#{random}"
+    response = @application.groups
+    response.entities.size.should eq size+1
+  end
+
+  it "should be able to create and retrieve devices" do
+    response = @application.devices
+    size = response.entities.size
+    random = SecureRandom.hex
+    @application.create_entity :devices, path: "test-#{random}"
+    response = @application.devices
+    response.entities.size.should eq size+1
+  end
+
+  it "should be able to create and retrieve assets" do
+    response = @application.assets
+    size = response.entities.size
+    random = SecureRandom.hex
+    @application.create_entity :assets, path: "test-#{random}", owner: @application.current_user.uuid
+    response = @application.assets
+    response.entities.size.should eq size+1
+  end
+
+  it "should be able to create and retrieve folders" do
+    response = @application.folders
+    size = response.entities.size
+    random = SecureRandom.hex
+    @application.create_entity :folders, path: "test-#{random}", owner: @application.current_user.uuid
+    response = @application.folders
+    response.entities.size.should eq size+1
+  end
+
+  it "should be able to create and retrieve events and retrieve counters" do
+    # clear events
+    {} while @application.events.entities.size > 0
+
+    events_in = []
+    events_in  << {timestamp: 0, category: 'test', counters: { test: 1 }}
+    events_in  << {timestamp: 0, category: 'testme', counters: { testme: 1 }}
+    events_in  << {timestamp: 0, counters: { test: 1 }}
+    events_in.each {|e| @application.create_entity :events, e }
+
+    events_out = []
+    events_out << @application.events.entity
+    events_out << @application.events.entity
+    events_out << @application.events.entity
+
+    (0..2).each do |i|
+      events_in[i][:category].should eq events_out[i]['category']
+    end
+
+    response = @application.events
+    response.entities.size.should eq 0
+
+    # get and test counters
+    counter_names = @application.counter_names
+    counter_names.should include 'test'
+    counter_names.should include 'testme'
+
+    response = @application.counter 'test'
+    counter = response.data.counters.first
+    counter.name.should eq 'test'
+    counter.values.last.first.value.should eq 2
+  end
+
+  it "should be able to create, retrieve, and delete roles via rolenames" do
+    size = @application.rolenames.size
+
+    role_name = "test-#{SecureRandom.hex}"
+    @application.create_entity :rolenames, name: role_name
+    role_names = @application.rolenames
+    role_names.size.should eq size+1
+    role_names.should include role_name
+
+    @application['rolenames'][role_name].delete
+    @application.rolenames.size.should eq size
+  end
+
+  it "should be able to create, retrieve, and delete roles" do
+    size = @application.roles.collection.size
+
+    role_name = "test-#{SecureRandom.hex}"
+    @application.create_entity :role, name: role_name, title: 'title', inactivity: 0
+    roles = @application.roles.collection
+    roles.size.should eq size+1
+    role = roles.detect {|r| r.name == role_name }
+    role.should_not be_nil
+
+    role.delete
+    @application.roles.collection.size.should eq size
+  end
+
+  it "should be able to add/remove permissions from a user" do
+    user = create_random_user @application
+    permission = 'post:/users/*'
+    user.resource['permissions'].post permission: permission
+
+    permissions = user.resource['permissions'].get.data.data
+    permissions.size.should eq 1
+    permissions.first.should eq permission
+
+    user.resource['permissions'].delete({params: { permission: permission }})
+
+    permissions = user.resource['permissions'].get.collection.entities
+    permissions.size.should eq 0
+  end
+
+  it "should be able to add/remove a user from a roles" do
+    user = create_random_user @application
+
+    roles = user.resource['roles'].get.entities
+    size = roles.size
+
+    @application["roles/admin/users/#{user.uuid}"].post nil
+
+    roles = user.resource['roles'].get.entities
+    roles.size.should == size+1
+
+    @application["roles/admin/users/#{user.uuid}"].delete
+
+    roles = user.resource['roles'].get.entities
+    roles.size.should == size
+  end
+
+  it "should be able to create a new collection and access it" do # todo
+    entities = (1..4).collect do |i|
+      { name: "test_#{i}" }
+    end
+    @application.create_entities 'tests', entities
+    response = @application['tests'].get
+    collection = response.collection
+    collection.size.should eq 4
+  end
+
+end

data/spec/usergrid/core/collection_spec.rb

@@ -0,0 +1,65 @@
+describe Usergrid::Collection do
+
+  before :all do
+    @application = create_random_application
+
+    @collection = @application['tests'].collection
+    @entity_data = []
+    (1..10).each do |i|
+      test = { name: "test_#{i}" }
+      @entity_data << test
+      @collection.create_entity test
+    end
+
+    @user = create_random_user @application, true
+  end
+
+  after :all do
+    @user.delete
+    delete_application @application
+  end
+
+  it "should be able to query a collection" do
+    @collection.query "select * where name = \'#{@entity_data[0][:name]}\'"
+    @collection.size.should eq 1
+  end
+
+  it "should be able to find an entity" do
+    @collection.query
+    entity = @collection.detect { |e| e.name == @entity_data[5][:name] }
+    entity.should_not be_nil
+    entity.name.should eq @entity_data[5][:name]
+  end
+
+  it "should be able to respect query reversal and limits" do
+    @collection.query nil, reversed: true, start: 5, cursor: nil, limit: 2, permission: nil
+    @collection.size.should eq 2
+    @collection[0].name.should eq @entity_data[9][:name]
+    @collection[1].name.should eq @entity_data[8][:name]
+  end
+
+  it "should be able to select the start by uuid" do
+    @collection.query
+    uuid = @collection[4].uuid
+    @collection.query nil, reversed: false, start: uuid, cursor: nil, limit: 3, permission: nil
+    @collection.size.should eq 3
+    @collection.first.uuid.should eq uuid
+    @collection[2].name.should eq @entity_data[6][:name]
+  end
+
+  it "should be able to page forward by cursor" do
+    @collection.query nil, limit: 2
+    @collection.next_page
+    @collection.size.should eq 2
+    @collection[0].name.should eq @entity_data[2][:name]
+  end
+
+  #it "should be able to update based on a query" do # todo: enable when server is fixed
+  #  @collection.update({new_field: 'new_value'}, "select * where name = \'#{@entity_data[4][:name]}\'")
+  #  @collection.query
+  #  entity = @collection.detect { |e| e.new_field == 'new_value' }
+  #  entity.should_not be_nil
+  #  entity.name.should eq @entity_data[4][:name]
+  #end
+
+end

data/spec/usergrid/core/entity_spec.rb

@@ -0,0 +1,45 @@
+describe Usergrid::Entity do
+
+  before :all do
+    @application = create_random_application
+    @user = create_random_user @application, true
+  end
+
+  after :all do
+    @user.delete
+    delete_application @application
+  end
+
+  it "should be able to retrieve its collection" do
+    collection = @user.collection
+    collection.should_not be_nil
+    u = collection.detect {|u| u.uuid == @user.uuid }
+    u.uuid.should eq @user.uuid
+  end
+
+  it "should be able to reload its data" do
+    old_name = @user.name
+    @user.name = 'new name'
+    @user.name.should eq 'new name'
+    @user.get
+    @user.name.should eq old_name
+  end
+
+  it "should be able to save" do
+    @user.name = 'new name'
+    @user.save
+    @user.name.should eq 'new name'
+  end
+
+  it "should be able to print itself" do
+    p = @user.to_s
+    p.start_with?('resource').should be_true
+  end
+
+  it "should know if it has data" do
+    @user.data?.should be_true
+    empty = Usergrid::Entity.new 'url', 'url'
+    empty.data?.should be_false
+  end
+
+end

data/spec/usergrid/core/management_spec.rb

@@ -0,0 +1,36 @@
+describe Usergrid::Management do
+
+  before :all do
+    @base_resource = Usergrid::Resource.new(SPEC_SETTINGS[:api_url])
+    @management = @base_resource.management
+    @management.login SPEC_SETTINGS[:management][:username], SPEC_SETTINGS[:management][:password]
+  end
+
+  it "should be able to create an organization" do
+    # can't delete an org or a user, so we create new random ones and leave them
+    random = SecureRandom.hex
+    org_name = "test_org_#{random}"
+    user_name = "test_admin_#{random}"
+    response = @management.create_organization("#{org_name}",
+                                               "#{user_name}",
+                                               "#{user_name}",
+                                               "#{user_name}@email.com",
+                                               "#{random}")
+    response.code.should eq 200
+    #@base_resource["users/#{user_name}"].delete
+  end
+
+  # this is broken on the server
+  #it "should be able to get organizations" do
+  #  response = @management.organizations
+  #end
+
+  it "should be able to get an organization" do
+    organization = @management.organization SPEC_SETTINGS[:organization][:name]
+    organization.should be_a Usergrid::Organization
+    org_ent = organization.get.entity
+    org_ent.uuid.should_not be_nil
+    org_ent.name.should eq SPEC_SETTINGS[:organization][:name]
+  end
+
+end

data/spec/usergrid/core/organization_spec.rb

@@ -0,0 +1,72 @@
+describe Usergrid::Organization do
+
+  before :all do
+    @management = Usergrid::Resource.new(SPEC_SETTINGS[:api_url]).management
+    @management.login SPEC_SETTINGS[:organization][:username], SPEC_SETTINGS[:organization][:password]
+    @organization = @management.organization SPEC_SETTINGS[:organization][:name]
+  end
+
+  it "should be able to create (and delete) an application" do
+    app_name = "test_app_#{SecureRandom.hex}"
+    app = @organization.create_application app_name
+    app.should be_an Usergrid::Application
+
+    response = @organization["applications/#{app_name}"].delete
+    response.code.should eq 200
+  end
+
+  it "should be able to get applications" do
+    response = @organization.applications
+    response.should be_an Array
+    if response.size > 0
+      app = response.first
+      app.should be_an Usergrid::Application
+    end
+  end
+
+  it "should be able to get users" do
+    response = @organization.users
+    response.code.should eq 200
+    response.entities.should be_an Array
+    response.entities[0].uuid.should_not be_nil
+  end
+
+  it "should be able to get a user" do
+    response = @organization.user(SPEC_SETTINGS[:organization][:username])
+    response.code.should eq 200
+    response.entity.uuid.should_not be_nil
+  end
+
+  it "should be able to get an application" do
+    app_name = "test_app_#{SecureRandom.hex}"
+    @organization.create_application app_name
+    begin
+      app = @organization.application app_name
+      app.should be_an Usergrid::Application
+    ensure
+      @organization["applications/#{app_name}"].delete
+    end
+  end
+
+  it "should be able to get feed" do
+    response = @organization.feed
+    entities = response.entities
+    entities.size.should be > 0
+    entities.first.uuid.should_not be_nil
+  end
+
+  it "should be able to get credentials" do
+    response = @organization.credentials
+    response.code.should eq 200
+    response.data.credentials.client_id.should_not be_nil
+    response.data.credentials.client_secret.should_not be_nil
+  end
+
+  it "should be able to generate credentials" do
+    response = @organization.generate_credentials
+    response.code.should eq 200
+    response.data.credentials.client_id.should_not be_nil
+    response.data.credentials.client_secret.should_not be_nil
+  end
+
+end