groove-ey-core 3.6.1

data/spec/features_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  let!(:public_feature) do
+    if Ey::Core::Client.mocking?
+      client.create_feature(
+                     :id      => "public_feature",
+                     :privacy => "public",
+                     :name    => "A Public Feature",
+                    )
+    else
+      client.features.all.first
+    end
+  end
+
+  let!(:other_feature)  do
+    if Ey::Core::Client.mocking?
+      client.create_feature(
+                     :id      => "other_feature",
+                     :privacy => "private",
+                     :name    => "Another Feature",
+                    )
+    else
+      client.features.all.last
+    end
+  end
+
+  context "with an account" do
+    let!(:account) { create_account(client: client) }
+
+    it "should list account features" do
+      client.features.get(other_feature.identity).enable!(account)
+
+      expect(account.features.all.size).to be > 0
+
+      feature = account.features.first(id: other_feature.id)
+
+      expect(feature.id).to          eq(other_feature.id)
+      expect(feature.name).to        eq(other_feature.name)
+      expect(feature.description).to eq(other_feature.description)
+    end
+
+    it "should enable feature" do
+      expect {
+        client.features.first.enable!(account)
+      }.to change { account.features.all.size }.by(1)
+    end
+
+    it "should disable feature" do
+      client.features.first.enable!(account)
+      expect {
+        client.features.first.disable!(account)
+      }.to change { account.features.all.size }.by(-1)
+    end
+  end
+
+  context "without an account" do
+    it "should list features" do
+      expect(client.features.all).to include(public_feature)
+    end
+
+    it "should show a feature" do
+      feature = client.features.get(public_feature.identity)
+
+      expect(feature).not_to be_nil
+
+      expect(feature.id).to          eq(public_feature.identity)
+      expect(feature.name).to        eq(public_feature.name)
+      expect(feature.description).to eq(public_feature.description)
+    end
+  end
+
+  context "with multiple accounts" do
+    it "should list all enabled features"
+    it "should list an account's enabled features"
+  end
+end

data/spec/firewalls_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe "firewalls" do
+  let(:client)       { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+
+  it "creates a firewall" do
+    pending "Not implemented"
+
+    name     = Faker::Name.first_name
+    location = "us-west-2"
+
+    firewall = client.firewalls.create!(
+      :provider    => provider,
+      :name        => name,
+      :location    => location,
+      :environment => environment.id,
+    ).resource!
+
+    expect(firewall.id).not_to be_nil
+    expect(firewall.provisioned_id).not_to be_nil
+    expect(firewall.provider).to eq(provider)
+    expect(firewall.name).to     eq(name)
+    expect(firewall.location).to eq(location)
+    expect(firewall.environment).to eq(environment)
+  end
+
+  context "with a firewall" do
+    before(:each) { pending "Not implemented" }
+
+    let!(:firewall) { client.firewalls.create!(provider: provider, name: Faker::Name.first_name, location: "us-west-2", environment: environment.id).resource! }
+
+    it "destroys a firewall" do
+      firewall.destroy.ready!
+
+      expect(firewall.reload.deleted_at).not_to be_nil
+    end
+
+    it "should create a rule" do
+      rule = client.firewall_rules.create!(
+        :firewall_id => firewall.id,
+      ).resource!
+
+      expect(rule.source).to eq("0.0.0.0/0")
+      expect(rule.port_range).to eq(0..65535)
+    end
+
+    it "creates a rule with a firewall as the source" do
+      other_firewall = client.firewalls.create!(provider: provider, name: Faker::Name.first_name, location: "us-west-2").resource!
+
+      rule = client.firewall_rules.create!(
+        :firewall_id => firewall.id,
+        :source      => other_firewall.id,
+        :port_range  => "80-443",
+      ).resource!
+
+      expect(rule.source.to_i).to     eq(other_firewall.id)
+      expect(rule.source_firewall).to eq(other_firewall)
+      expect(rule.port_range).to      eq(80..443)
+    end
+
+    context "with a firewall rule" do
+      let!(:rule) { client.firewall_rules.create!(firewall_id: firewall.id).resource! }
+
+      it "destroys a rule" do
+        expect { rule.destroy.ready! }.to change { client.firewall_rules.all.size }.by(-1)
+        expect(rule.reload.deleted_at).not_to be_nil
+      end
+
+      it "is part of the firewall's rules list" do
+        expect(firewall.rules.count).to eq(1)
+        expect(firewall.rules.first.id).to eq(rule.id)
+      end
+    end
+  end
+
+  context "with multiple firewalls" do
+    it "lists all firewalls"
+    it "lists firewalls by name"
+    it "lists a firewall's rules"
+  end
+end

data/spec/gems_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "gems" do
+  let!(:client) { create_client }
+
+  it "finds a gem" do
+    gem = client.gems.get("ey-core")
+    expect(gem.current_version).to eq(Ey::Core::VERSION)
+    expect(gem.name).to eq("ey-core")
+  end
+end

data/spec/keypair_deployments_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "as a user" do
+  let(:client)       { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+  let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+  it "creates a keypair deployment" do
+    keypair_deployment = client.keypair_deployments.create(keypair: keypair, environment: environment)
+
+    expect(keypair_deployment.identity).not_to be_nil
+    expect(keypair_deployment.keypair).to eq(keypair)
+    expect(keypair_deployment.environment).to eq(environment)
+  end
+
+  context "with a keypair deployment" do
+    let!(:keypair_deployment) { client.keypair_deployments.create(keypair: keypair, environment: environment) }
+
+    it "lists the keypair deployment" do
+      expect(client.keypair_deployments.all).to include(keypair_deployment)
+    end
+
+    it "lists an environment's keypairs" do
+      expect(environment.keypairs.all.to_a).to eq([keypair])
+    end
+
+    it "lists a keypair's deployments"
+    it "searches keypairs by name"
+    it "searches keypairs by fingerprint"
+  end
+end

data/spec/keypairs_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+
+  it "creates a keypair" do
+    name    = SecureRandom.hex(6)
+    ssh_key = SSHKey.generate
+
+    keypair = client.keypairs.create(name: name, public_key: ssh_key.ssh_public_key)
+
+    expect(keypair.application).to be_nil
+    expect(keypair.identity).not_to be_nil
+    expect(keypair.fingerprint).to be
+
+    expect(keypair.name).to        eq(name)
+    expect(keypair.public_key).to  eq(ssh_key.ssh_public_key)
+    expect(keypair.user).to        eq(client.users.current)
+  end
+
+  context "with a keypair" do
+    let!(:account)     { create_account(client: client) }
+    let!(:environment) { create_environment(account: account, name: SecureRandom.hex(6), boot: false) }
+    let!(:keypair)     { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+    it "deploys to an environment" do
+      keypair_deployment = keypair.deploy(environment)
+
+      expect(keypair_deployment.identity).not_to be_nil
+      expect(keypair_deployment.keypair).to eq(keypair)
+      expect(keypair_deployment.environment).to eq(environment)
+    end
+
+    context "with many keypairs" do
+      let!(:other_a) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+      let!(:other_b) { client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key) }
+
+      it "lists a user's keypairs" do
+        expect(client.users.current.keypairs.all).to match_array([keypair, other_a, other_b])
+      end
+
+      it "searches keypairs by name" do
+        expect(client.keypairs.all(name: other_a.name)).to match_array([other_a])
+      end
+
+      it "searches keypairs by fingerprint" do
+        expect(client.keypairs.all(fingerprint: other_b.fingerprint)).to match_array([other_b])
+      end
+    end
+  end
+end

data/spec/legacy_alerts_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+
+  context "with an account", :mock_only do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:environment) { create_environment(account: account, name: Faker::Name.name) }
+    let(:server)       { environment.servers.first }
+    let(:legacy_alert) { client.legacy_alerts.get(1001) }
+
+    before do
+      create_legacy_alert(client, id: 1001,
+                              type: "cpu",
+                          severity: "warning",
+                            server: server,
+                      acknowledged: false)
+    end
+
+    it "fetches a legacy alert" do
+      a = client.legacy_alerts.get(1001)
+
+      expect(a).not_to be_nil
+      expect(a.id).to          eq(1001)
+      expect(a.type).to        eq("cpu")
+      expect(a.severity).to    eq("warning")
+      expect(a.acknowledged).to be false
+      expect(a.server).to      eq(server)
+    end
+
+    it "lists legacy alerts" do
+      legacy_alerts = client.legacy_alerts.all
+      expect(legacy_alerts.size).to be(1)
+
+      a = legacy_alerts.first
+      expect(a.id).to          eq(1001)
+      expect(a.type).to        eq("cpu")
+      expect(a.severity).to    eq("warning")
+      expect(a.acknowledged).to be false
+      expect(a.server).to      eq(server)
+    end
+  end
+end

data/spec/load_balancers_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client)   { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates a load balancer" do
+    name = Faker::Name.first_name
+    location = "us-east-1"
+
+    req = client.load_balancers.create!(provider: provider,
+                                        name: name,
+                                        location: location)
+
+    load_balancer = req.resource!
+
+    expect(load_balancer.name).to     eq(name)
+    expect(load_balancer.location).to eq(location)
+    expect(load_balancer.provider).to eq(provider)
+  end
+
+  context "with a load balancer" do
+    let!(:load_balancer) { client.load_balancers.create!(provider: provider, name: Faker::Name.first_name, location: "us-east-1").resource! }
+
+    it "destroys a load balancer" do
+      expect { load_balancer.destroy }.to change { client.load_balancers.all.size }.by(-1)
+      expect(load_balancer.reload.deleted_at).not_to be_nil
+    end
+  end
+end

data/spec/logical_databases_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe "as a client" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  context "with a database service" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+
+    it "creates a logical database" do
+      logical_database = nil
+      name = SecureRandom.hex(6)
+      extensions = ["postgis"]
+
+      expect {
+        logical_database = database_service.databases.create!(name: name, extensions: extensions).resource!
+      }.to change { client.logical_databases.size }.by(1)
+
+      expect(logical_database.name).to         eq(name)
+      expect(logical_database.username).not_to be_nil
+      expect(logical_database.password).not_to be_nil
+      expect(logical_database.extensions).to   eq(extensions)
+      expect(logical_database.service).to      eq(database_service)
+    end
+
+    context "with a logical database" do
+      let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
+
+      it "destroys the logical database" do
+        expect {
+          logical_database.destroy.ready!
+        }.to change  { logical_database.reload.deleted_at }.from(nil).
+          and change { database_service.databases.reload.all.size }.by(-1)
+      end
+    end
+  end
+end

data/spec/logs_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'logs', :mock_only  do
+  let(:client)        { create_client }
+  let!(:account)      { create_account(client: client) }
+  let!(:provider)     { create_provider(account: account) }
+  let!(:environment)  { create_environment(account: account, name: Faker::Name.first_name) }
+  let(:server_client) { create_server_client(client.servers.all.first) }
+
+  describe "create log" do
+    it "can upload a file" do
+      log = server_client.logs.create!(
+        :component_action_id => "123",
+        :file                => "{}",
+        :filename            => "blah.json",
+        :mime_type           => "application/json"
+      )
+      expect(log.id).to be
+      expect(log.download_url).to be
+      expect(log.filename).to eq("blah.json")
+    end
+
+    it "can create a log using body content" do
+      body = "{}"
+      log = server_client.logs.create!(
+        :body                => body,
+        :component_action_id => "123",
+        :mime_type           => "application/json",
+      )
+      expect(log.id).to be
+      expect(log.filename).to be
+      expect(log.download_url).to be
+    end
+  end
+
+  it "can fetch a log" do
+    created_log = server_client.logs.create!(
+      :component_action_id => "123",
+      :file                => "{}",
+      :mime_type           => "application/json"
+    )
+    expect(client.logs.get!(created_log.id)).to eq(created_log)
+  end
+end

data/spec/memberships_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe "memberships" do
+  let!(:user)         { create_user }
+  let!(:client)       { create_client(user: user) }
+  let!(:account)      { create_account(owner: user) }
+  let!(:collaborator) { create_user }
+
+  it "should create a membership for an email" do
+    email = Faker::Internet.email
+
+    membership = client.memberships.create!(account: account, role: "collaborator", email: email, redirect_url: "http://example.com")
+
+    expect(membership.email).to eq(email)
+    expect(membership.user).to be_nil
+    expect(membership.role).to eq("collaborator")
+    expect(membership.redirect_url).to eq("http://example.com")
+  end
+
+  it "should create a membership for a user" do
+    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    expect(membership.email).to eq(collaborator.email)
+    expect(membership.user).to eq(collaborator)
+    expect(membership.role).to eq("collaborator")
+  end
+
+  it "should get a membership" do
+    membership = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    expect(client.memberships.get(membership.id)).to eq(membership)
+
+    expect(account.memberships.size).to eq 1
+    expect(account.memberships.first).to eq membership
+  end
+
+  it "should be able to accept invites", :mock_only do
+    account = client.accounts.create!(owner: user, name: Faker::Name.first_name, type: "normal")
+    collaborator  = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+
+    collaborator.reload
+    expect(collaborator.accounts.all).to be_empty
+    account.reload
+    expect(account.users.all.size).to eq 1
+    expect(account.users.all.map(&:id)).to eq [user.id]
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+
+    invite = client.memberships.create!(account: account, role: "collaborator", user: collaborator)
+
+    collaborator.reload
+    expect(collaborator.accounts.all).to be_empty
+    account.reload
+    expect(account.users.all.size).to eq 1
+    expect(account.users.all.map(&:id)).to eq [user.id]
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+
+    collaborator_client = create_client(user: collaborator)
+    membership = collaborator_client.memberships.get(invite.id)
+    membership.accept!
+
+    collaborator.reload
+    expect(collaborator.accounts.all.size).to eq 1
+    expect(collaborator.accounts.first.id).to eq account.id
+    account.reload
+    expect(account.users.all.size).to eq 2
+    expect(account.users.all.map(&:id).sort).to eq [user.id, collaborator.id].sort
+    expect(account.owners.all.size).to eq 1
+    expect(account.owners.all.map(&:id)).to eq [user.id]
+  end
+
+end