ey_resolver 0.1.0

data/lib/ey_resolver/mock.rb

@@ -0,0 +1,5 @@
+class EY::Resolver
+  module Mock
+    require 'ey_resolver/mock/models'
+  end
+end

data/lib/ey_resolver/mock/models.rb

@@ -0,0 +1,13 @@
+module EY::Resolver::Mock
+  require 'ey_resolver/mock/models/user'
+  require 'ey_resolver/mock/models/account'
+  require 'ey_resolver/mock/models/app'
+  require 'ey_resolver/mock/models/environment'
+  require 'ey_resolver/mock/models/app_environment'
+
+  require 'dm-migrations'
+  require 'dm-aggregates'
+  DataMapper.setup(:default, "sqlite::memory:")
+  DataMapper.finalize
+  DataMapper.auto_migrate!
+end

data/lib/ey_resolver/mock/models/account.rb

@@ -0,0 +1,12 @@
+require 'dm-core'
+
+class Account
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  belongs_to :user
+  has n, :environments
+  has n, :apps
+end

data/lib/ey_resolver/mock/models/app.rb

@@ -0,0 +1,18 @@
+require 'gitable'
+require 'dm-core'
+
+class App
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+  property :repository_uri, String
+
+  belongs_to :account
+  has n, :app_environments
+  has n, :environments, :through => :app_environments
+
+  def gitable_uri
+    Gitable::URI.parse(repository_uri)
+  end
+end

data/lib/ey_resolver/mock/models/app_environment.rb

@@ -0,0 +1,16 @@
+require 'dm-core'
+
+class AppEnvironment
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :app_id, Integer
+  property :environment_id, Integer
+
+  belongs_to :app
+  belongs_to :environment
+
+  def inspect
+    "#<AppEnvironment app:#{app.name} env:#{environment.name}>"
+  end
+end

data/lib/ey_resolver/mock/models/environment.rb

@@ -0,0 +1,16 @@
+require 'dm-core'
+
+class Environment
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  belongs_to :account
+  has n, :app_environments
+  has n, :apps, :through => :app_environments
+
+  def inspect
+    "#<Environment name:#{name} account:#{account.name}>"
+  end
+end

data/lib/ey_resolver/mock/models/user.rb

@@ -0,0 +1,10 @@
+require 'dm-core'
+
+class User
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  has n, :accounts
+end

data/lib/ey_resolver/query.rb

@@ -0,0 +1,68 @@
+require 'gitable'
+
+class EY::Resolver
+  class Query
+
+    def initialize(params)
+      self.query = params
+    end
+
+    def account_name()     query[:account_name]     end
+    def app_name()         query[:app_name]         end
+    def environment_name() query[:environment_name] end
+    def remotes()          query[:remotes]          end
+
+    def count_matches(&block)
+      query.count(&block)
+    end
+
+    def app_constrained?
+      app_name || remotes
+    end
+
+    def app_unconstrained?
+      !app_constrained?
+    end
+
+    def env_constrained?
+      environment_name || app_name || remotes
+    end
+
+    def env_unconstrained?
+      !env_constrained?
+    end
+
+    # The only case where an unconstrained set would return a single record is if
+    # there is only one possible candidate. If we don't have an app name or a
+    # repository_uri at all, then how do we know it's the right one anyway?
+    def unconstrained?
+      query.all? { |k,v| v.nil? || v.empty? || v.to_s.empty? }
+    end
+
+    private
+
+    attr_reader :query
+
+    def query=(params)
+      @query = {}
+      params.each do |key,val|
+        if converted = convert_value(key,val)
+          @query[key.to_sym] = converted
+        end
+      end
+
+      @query.delete(:remotes) if @query[:app_name]
+      @query.freeze
+    end
+
+    def convert_value(key, val)
+      if key.to_sym == :remotes
+        return nil if val.nil? || val.empty?
+        val.reject {|uri| uri.to_s.empty? }.map { |uri| Gitable::URI.parse_when_valid(uri) }.compact
+      else
+        norm = val.to_s.gsub(/[^\w-]+/,'')
+        norm.empty? ? nil : norm
+      end
+    end
+  end
+end

data/lib/ey_resolver/version.rb

@@ -0,0 +1,5 @@
+module EY
+  class Resolver
+    VERSION = "0.1.0"
+  end
+end

data/spec/account_resolver_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe EY::Resolver::AppEnvResolver do
+
+  def account_resolver(*args)
+    EY::Resolver.account_resolver(user, to_query(args))
+  end
+
+  def accounts(*models)
+    models.map { |model| model[:account] }
+  end
+
+  before(:all) do
+    # More correct names, even though it doesn't matter
+    @ey = @production
+    @me = @me_dup
+    @no = @account
+  end
+
+  describe "#matches" do
+    it "return empty if the conditions are empty" do
+      account_resolver(                 ).matches.should == []
+      account_resolver(nil, nil, nil, []).matches.should == []
+      account_resolver('', '', '', [''] ).matches.should == []
+    end
+
+    it "returns empty when there is no account match" do
+      account_resolver('gibberish').matches.should == []
+    end
+
+    it "ignore app name if it doesn't match" do
+      account_resolver('me', 'bigapp').matches.should == accounts(@me)
+    end
+
+    it "finds account with no apps" do
+      account_resolver("no").matches.should == accounts(@no)
+    end
+
+    it "ignores environment" do
+      account_resolver(nil, 'big', 'gibberish').matches.should == accounts(@ey)
+    end
+
+    it "returns more matches when there is more than one match" do
+      account_resolver(nil, nil, nil, ["git://github.com/repo/dup.git"]).matches.should == accounts(@ey, @me)
+      account_resolver('e').matches.should == accounts(@ey, @me)
+    end
+
+    it "returns one deployment whene there is only one match" do
+      account_resolver('ey'          ).matches.should == accounts(@ey)
+      account_resolver(nil,  "bigapp").matches.should == accounts(@ey)
+      account_resolver(nil,  "app"   ).matches.should == accounts(@ey, @me)
+      account_resolver("ey", "app"   ).matches.should == accounts(@ey)
+      account_resolver("me"          ).matches.should == accounts(@me)
+    end
+
+    it "uses repo as a hint but doesn't require it" do
+      account_resolver("ey", nil, nil, ["git://github.com/repo/app.git"]).matches.should == accounts(@ey)
+      account_resolver("me", nil, nil, ["git://github.com/repo/big.git"]).matches.should == accounts(@me)
+      account_resolver("no", nil, nil, ["git://github.com/repo/hug.git", "git://github.com/repo/big.git"]).matches.should == accounts(@no)
+    end
+
+    it "doesn't care about case" do
+      account_resolver("EY", "big").matches.should == accounts(@ey)
+      account_resolver("ey", "BiG").matches.should == accounts(@ey)
+    end
+
+    it "returns the match when an app is specified even when there is a repo" do
+      account_resolver("ey", "bigapp", nil, ["git://github.com/repo/app.git"]).matches.should == accounts(@ey)
+    end
+
+    it "returns the specific match even if there is a partial match" do
+      account_resolver('e', 'app').matches.should == accounts(@ey, @me)
+      account_resolver(nil, "app").matches.should == accounts(@ey, @me)
+    end
+
+    it "scopes searches under the correct account" do
+      account_resolver("ey", "dup").matches.should == accounts(@ey)
+      account_resolver("me", "dup").matches.should == accounts(@me)
+      account_resolver("ey", nil, nil, ["git://github.com/repo/dup.git"]).matches.should == accounts(@ey)
+      account_resolver("me", nil, nil, ["git://github.com/repo/dup.git"]).matches.should == accounts(@me)
+    end
+  end
+
+  describe "#errors" do
+    it "no account" do
+      account_resolver('gibberish', 'app', 'production').errors.should ==
+        [%|No account found matching "gibberish".|]
+    end
+
+    it "no app" do
+      account_resolver(nil, 'gibberish', 'app_dup').errors.should ==
+        [%|No application found matching "gibberish".|]
+    end
+
+    it "no env" do
+      account_resolver('ey', 'app', 'gibberish').errors.should ==
+        [%|No environment found matching "gibberish".|]
+    end
+
+    it "no account or app" do
+      account_resolver('gibberish', 'gibberish', nil).errors.should == [
+        %|No account found matching "gibberish".|,
+        %|No application found matching "gibberish".|,
+      ]
+    end
+
+    it "no account or app or env" do
+      account_resolver('gibberish', 'gibberish', 'gibberish').errors.should == [
+        %|No account found matching "gibberish".|,
+        %|No application found matching "gibberish".|,
+        %|No environment found matching "gibberish".|,
+      ]
+    end
+
+    it "repo not found" do
+      account_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"]).errors.should ==
+        [%|No application found matching remotes:\n\tgit://fake.com/fake/fake.git|]
+    end
+  end
+end

data/spec/app_env_resolver_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe EY::Resolver::AppEnvResolver do
+
+  def app_env_resolver(*args)
+    EY::Resolver.app_env_resolver(user, to_query(args))
+  end
+
+  def app_envs(*models)
+    models.map { |model| model[:app_env] }
+  end
+
+  describe "#matches" do
+    it "raises if the conditions are empty" do
+      app_env_resolver(                 ).matches.should == []
+      app_env_resolver(nil, nil, nil, []).matches.should == []
+      app_env_resolver('', '', '', [''] ).matches.should == []
+    end
+
+    it "raises if the conditions do not include an app or remotes" do
+      app_env_resolver(nil,  nil, 'app_dup'    ).matches.should == []
+      app_env_resolver('ey', nil,  nil         ).matches.should == []
+      app_env_resolver('ey', nil, 'app_dup'    ).matches.should == []
+      app_env_resolver('ey', nil, 'app_dup', []).matches.should == []
+    end
+
+    it "returns empty when there is no account match" do
+      app_env_resolver('gibberish', 'app', 'production').matches.should == []
+    end
+
+    it "returns empty when there is no app match" do
+      app_env_resolver(nil, 'gibberish', 'app_dup').matches.should == []
+    end
+
+    it "returns empty when there is no environment match" do
+      app_env_resolver(nil, 'app', 'gibberish').matches.should == []
+    end
+
+    it "returns empty when no matches" do
+      app_env_resolver(nil, 'bigapp', 'app_dup').matches.should == []
+      app_env_resolver(nil,  nil,     'app_dup', ["git://github.com/repo/app.git"]).matches.should == []
+    end
+
+    it "returns more matches when there is more than one match" do
+      app_env_resolver(nil,  "app", nil, nil                              ).matches.should == app_envs(@production, @staging)
+      app_env_resolver("ey", "app", nil, nil                              ).matches.should == app_envs(@production, @staging)
+      app_env_resolver(nil,   nil,  nil, ["git://github.com/repo/app.git"]).matches.should == app_envs(@production, @staging)
+      app_env_resolver(nil,   nil,  nil, ["git://github.com/repo/hug.git", "git://github.com/repo/big.git"]).matches.should == app_envs(@hugeprod, @big)
+      app_env_resolver(nil,   nil,  nil, ["git://github.com/repo/dup.git"]).matches.should == app_envs(@ey_dup, @sumo, @me_dup)
+    end
+
+    it "returns one deployment whene there is only one match" do
+      app_env_resolver("ey", "big",  nil,         nil                              ).matches.should == app_envs(@big)
+      app_env_resolver(nil,   nil,  'production', ["git://github.com/repo/app.git"]).matches.should == app_envs(@production)
+      app_env_resolver(nil,  'app', "production", nil                              ).matches.should == app_envs(@production)
+      app_env_resolver(nil,   nil,  'staging',    ["git://github.com/repo/app.git"]).matches.should == app_envs(@staging)
+      app_env_resolver(nil,   nil,   nil,         ["git://github.com/repo/big.git"]).matches.should == app_envs(@big)
+      app_env_resolver(nil,   nil,  'bigapp',     ["git://github.com/repo/hug.git", "git://github.com/repo/big.git"]).matches.should == app_envs(@big)
+    end
+
+    it "doesn't care about case" do
+      app_env_resolver("EY", "big").matches.should == app_envs(@big)
+      app_env_resolver("ey", "BiG").matches.should == app_envs(@big)
+    end
+
+    it "returns the match when an app is specified even when there is a repo" do
+      app_env_resolver("ey", "bigapp", nil, ["git://github.com/repo/app.git"]).matches.should == app_envs(@big)
+    end
+
+    it "returns the specific match even if there is a partial match" do
+      app_env_resolver(nil, 'app', 'app_staging').matches.should == app_envs(@staging)
+      app_env_resolver(nil, "app", "staging"    ).matches.should == app_envs(@staging)
+    end
+
+    it "scopes searches under the correct account" do
+      app_env_resolver("ey", "dup", "dup",  nil                             ).matches.should == app_envs(@ey_dup)
+      app_env_resolver("me",  nil,  "dup", ["git://github.com/repo/dup.git"]).matches.should == app_envs(@me_dup)
+      app_env_resolver("me",  nil,   nil,  ["git://github.com/repo/dup.git"]).matches.should == app_envs(@me_dup)
+      app_env_resolver("me", "dup",  nil,   nil                             ).matches.should == app_envs(@me_dup)
+    end
+  end
+
+  describe "#errors" do
+
+    it "no constraints" do
+      app_env_resolver().errors.should ==
+        [%|Must search by account name, app name, remotes, or environment name.|]
+    end
+
+    it "no app constraints" do
+      app_env_resolver('ey').errors.should ==
+        [%|App name or repository remotes required.|]
+    end
+
+    it "no account" do
+      app_env_resolver('gibberish', 'app', 'production').errors.should ==
+        [%|No account found matching "gibberish".|]
+    end
+
+    it "no app" do
+      app_env_resolver(nil, 'gibberish', 'app_dup').errors.should ==
+        [%|No application found matching "gibberish".|]
+    end
+
+    it "app found, but not on account" do
+      app_env_resolver('no', 'bigapp', 'app_dup').errors.should == [
+        %|Application "bigapp" found, but does not exist in account "no".|,
+        %|Environment "app_dup" found, but does not exist in account "no".|,
+      ]
+    end
+
+    it "no env" do
+      app_env_resolver('ey', 'app', 'gibberish').errors.should ==
+        [%|No environment found matching "gibberish".|]
+    end
+
+    it "no env on account" do
+      app_env_resolver('me', 'other', 'production').errors.should ==
+        [%|Environment "production" found, but does not exist in account "me".|]
+    end
+
+    it "no account or app" do
+      app_env_resolver('gibberish', 'gibberish', nil).errors.should == [
+        %|No account found matching "gibberish".|,
+        %|No application found matching "gibberish".|,
+      ]
+    end
+
+    it "no account or app or env" do
+      app_env_resolver('gibberish', 'gibberish', 'gibberish').errors.should == [
+        %|No account found matching "gibberish".|,
+        %|No application found matching "gibberish".|,
+        %|No environment found matching "gibberish".|,
+      ]
+    end
+
+    it "repo not found" do
+      app_env_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"]).errors.should ==
+        [%|No application found matching remotes:\n\tgit://fake.com/fake/fake.git|]
+    end
+
+    it "repo not found in account" do
+      app_env_resolver('ey', nil, nil, ["git://github.com/repo/oth.git"]).errors.should ==
+        [%|Application "other" found, but does not exist in account "ey".|]
+    end
+
+    it "app and environment not associated" do
+      app_env_resolver('ey', 'bigapp', 'app_dup').errors.should ==
+        [%|Application "bigapp" and environment "app_dup" are not associated.|]
+      app_env_resolver(nil,   nil,     'app_dup', ["git://github.com/repo/app.git"]).errors.should ==
+        [%|Application "app" and environment "app_dup" are not associated.|]
+    end
+
+    it "app (by repo) does not have an environment" do
+      app_env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"]).errors.should ==
+        [%|No environment found for applications matching remotes:\n\tgit://github.com/repo/noe.git|]
+    end
+  end
+end