noah 0.0.5-jruby → 0.1-jruby

data/spec/noahapp_host_spec.rb

@@ -82,15 +82,15 @@ describe "Using the Host API", :reset_redis => false, :populate_sample_data => t
         response = last_response.should return_json
 
         response["result"].should == "failure"
-        response["error_message"].should == "[[:status, :not_member]]"
+        response["error_message"].should == "Status must be up, down or pending"
       end
     end
 
     describe "DELETE" do
       before(:all) do
-        @h = Host.create(:name => 'h', :status => 'up')
+        @h = Noah::Host.create(:name => 'h', :status => 'up')
         sparms = {:name => 's', :status => "up"}
-        @h.services << Service.create(sparms.merge({:host => @h}))
+        @h.services << Noah::Service.create(sparms.merge({:host => @h}))
         @h.save
         @s = @h.services.first
       end  

data/spec/noahapp_service_spec.rb

@@ -4,10 +4,10 @@ describe "Using the Service API", :reset_redis => false, :populate_sample_data =
   before(:all) do
     @sample_host = {:name => 'rspec_sample_host', :status => 'up'}
     @sample_service = {:name => 'rspec_sample_service', :status => 'up'}
-    @h = Host.create(:name => 'rspec_sample_host', :status => 'up')
-    @h.services << Service.create({:host => @h}.merge(@sample_service))
+    @h = Noah::Host.create(:name => 'rspec_sample_host', :status => 'up')
+    @h.services << Noah::Service.create({:host => @h}.merge(@sample_service))
     @h.save
-    @s = Service.find(@sample_service).first
+    @s = Noah::Service.find(@sample_service).first
   end  
   describe "calling" do
     
@@ -57,8 +57,8 @@ describe "Using the Service API", :reset_redis => false, :populate_sample_data =
         response["id"].nil?.should == false
         response["name"].should == @payload[:name]
         response["host"].should == @payload[:host]
-        Service.find(:name => @payload[:name]).size.should == 1
-        Service.find(:name => @payload[:name]).first.is_new?.should == true
+        Noah::Service.find(:name => @payload[:name]).size.should == 1
+        Noah::Service.find(:name => @payload[:name]).first.is_new?.should == true
       end
       it "new service without host should not work" do
         put "/s/foobar", {:name => "foobar", :status => "up"}.to_json, "CONTENT_TYPE" => "application/json"
@@ -68,7 +68,7 @@ describe "Using the Service API", :reset_redis => false, :populate_sample_data =
         put "/s/foobar", {:name => "foobar", :status => "fsck", :host => @h.name}.to_json, "CONTENT_TYPE" => "application/json"
         last_response.should_not be_ok
         response = last_response.should return_json
-        response["error_message"].should == "[[:status, :not_member]]"
+        response["error_message"].should == "Status must be up, down or pending"
       end  
       it "new service with missing name should not work" do
         put "/s/foobar", {:status => "fsck", :host => @h.name}.to_json, "CONTENT_TYPE" => "application/json"
@@ -88,15 +88,15 @@ describe "Using the Service API", :reset_redis => false, :populate_sample_data =
         response["id"].nil?.should == false
         response["name"].should == @payload[:name]
         response["host"].should == @payload[:host]
-        Service.find(:name => @payload[:name]).size.should == 1
-        Service.find(:name => @payload[:name]).first.is_new?.should == false
+        Noah::Service.find(:name => @payload[:name]).size.should == 1
+        Noah::Service.find(:name => @payload[:name]).first.is_new?.should == false
       end
     end
 
     describe "DELETE" do
       before(:all) do
-        @h = Host.create(:name => "h1", :status => "up")
-        @h.services << Service.create(:name => "s1", :status => "up", :host => @h)
+        @h = Noah::Host.create(:name => "h1", :status => "up")
+        @h.services << Noah::Service.create(:name => "s1", :status => "up", :host => @h)
         @h.save
         @s = @h.services.first
       end  

data/spec/noahapp_watcher_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Using the Watcher API", :reset_redis => true do
+  before(:each) do
+    endpoint = 'http://localhost:4567/webhook'
+    Ohm.redis.flushdb
+    a = Noah::Application.create :name => 'fooapp'
+    a.watch! :endpoint => endpoint
+    c = Noah::Configuration.create :name => 'fooconfig'
+    c.watch! :endpoint => endpoint
+    h = Noah::Host.create :name => 'localhost', :status => 'up'
+    h.watch! :endpoint => endpoint
+    s = Noah::Service.create :name => 'localhostservice', :status => 'up', :host => h
+    s.watch! :endpoint => endpoint
+  end
+
+  after(:all) do
+    Ohm.redis.flushdb
+  end
+
+  describe "calling" do
+
+    describe "GET" do
+      it "all watches should work" do
+        get '/w'
+        last_response.should be_ok
+        response = last_response.should return_json
+        response.is_a?(Array).should == true
+        response.size.should == 4
+      end
+
+      it "named watch should work" do
+        w = Noah::Watcher.create(:pattern => '//noah/application/myapp', :endpoint => 'http://localhost/webhook')
+        get "/w/#{w.name}"
+        last_response.should be_ok
+        response = last_response.should return_json
+        response['pattern'].should == w.pattern
+        response['endpoint'].should == w.endpoint
+      end
+
+      it "invalid watch should not work" do
+        get '/w/asdfasdfasdfasdfasdfsdf'
+        last_response.should be_missing
+      end
+    end
+
+    describe "PUT" do
+      it "new watch should work" do
+        data = {:pattern => "//noah/application", :endpoint => "http://myendpoint/webhook"}
+        put '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_ok
+        response = last_response.should return_json
+        response['pattern'].should == data[:pattern]
+        response['endpoint'].should == data[:endpoint]
+        w = Noah::Watcher.find(data).first
+        w.pattern.should == data[:pattern]
+        w.endpoint.should == data[:endpoint]
+      end
+
+      it "new watch without pattern should not work" do
+        data = {:endpoint => "http://myendpoint/webhook"}
+        put '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_invalid
+      end
+
+      it "new watch without endpoint should not work" do
+        data = {:pattern => "//noah/application"}
+        put '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_invalid
+      end
+
+      it "new watch that supercedes existing should not work" do
+        Noah::Watcher.create(:endpoint => 'http://myendpoint/webhook', :pattern => '//noah/application/foo')
+        data = {:endpoint => "http://myendpoint/webhook", :pattern => '//noah/application'}
+        put '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should_not be_ok
+        response = last_response.should return_json
+        response['error_message'].should == 'Pattern would overwrite existing'
+      end
+
+      it "new watch that subsets an existing should not work" do
+        Noah::Watcher.create(:endpoint => 'http://myendpoint/webhook', :pattern => '//noah/application')
+        data = {:endpoint => "http://myendpoint/webhook", :pattern => '//noah/application/foo'}
+        put '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should_not be_ok
+        response = last_response.should return_json
+        response['error_message'].should == 'Pattern is already provided'
+      end
+    end
+
+    describe "DELETE" do
+      it "delete an existing watch should work" do
+        data = {:endpoint => "http://myendpoint/webhookd", :pattern => '//noah/application/d'}
+        w = Noah::Watcher.create(data)
+        delete '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_ok
+        response = last_response.should return_json
+        response['pattern'].should == data[:pattern]
+        response['endpoint'].should == data[:endpoint]
+        response['name'].should_not == "null"
+        Noah::Watcher.find(data).size.should == 0
+      end
+
+      it "delete an invalid watch should not work" do
+        data = {:endpoint => 'missing', :pattern => '//noah/application/dag'}
+        delete '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_missing
+      end
+
+      it "delete without pattern should not work" do
+        data = {:endpoint => "invalid"}
+        delete '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_invalid
+      end
+
+      it "delete without endpoint should not work" do
+        data = {:pattern => "//noah/invalid"}
+        delete '/w', data.to_json, "CONTENT_TYPE" => "application/json"
+        last_response.should be_invalid
+      end
+    end
+  end
+end  

data/spec/service_spec.rb

@@ -8,9 +8,9 @@ describe "Noah Service Model", :reset_redis => true do
       servicestatus = "up"
       hostname = "mytesthost1"
       hoststatus = "up"
-      host = Host.create(:name => hostname, :status => hoststatus)
+      host = Noah::Host.create(:name => hostname, :status => hoststatus)
       host.save
-      service = Service.create(:name => servicename, :status => servicestatus, :host => host)
+      service = Noah::Service.create(:name => servicename, :status => servicestatus, :host => host)
       service.valid?.should == true
       service.save
       service.name.should == servicename
@@ -20,45 +20,45 @@ describe "Noah Service Model", :reset_redis => true do
     end
 
     it "create a new Service with find_or_create" do
-      host = Host.create(:name => "h1", :status => "up")
+      host = Noah::Host.create(:name => "h1", :status => "up")
       host.save
-      service = Service.find_or_create(:name => "s1", :status => "up", :host => host)
+      service = Noah::Service.find_or_create(:name => "s1", :status => "up", :host => host)
       service.save
       service.is_new?.should == true
     end
 
     it "update an existing Service with find_or_create" do
-      host = Host.create(:name => "h2", :status => "up")
+      host = Noah::Host.create(:name => "h2", :status => "up")
       host.save
-      service = Service.find_or_create(:name => "s2", :status => "up", :host => host)
+      service = Noah::Service.find_or_create(:name => "s2", :status => "up", :host => host)
       service.save
       sleep 1
-      service2 = Service.find_or_create(:name => "s2", :status => "up", :host => host)
+      service2 = Noah::Service.find_or_create(:name => "s2", :status => "up", :host => host)
       service2.save
       service2.is_new?.should == false
     end
 
     it "delete a Service" do
-      h = Host.create(:name => "h1", :status => "up")
+      h = Noah::Host.create(:name => "h1", :status => "up")
       h.save
-      s = Service.create(:name => "s1", :status => "up", :host => h)
+      s = Noah::Service.create(:name => "s1", :status => "up", :host => h)
       s.save
-      s = Service.find(:name => "s1").first
+      s = Noah::Service.find(:name => "s1").first
       s.delete
-      s = Service.find(:name => "s1").first
+      s = Noah::Service.find(:name => "s1").first
       s.should == nil
     end
 
     it "find multiple Services" do
-      h = Host.create(:name => "h1", :status => "up")
+      h = Noah::Host.create(:name => "h1", :status => "up")
       if h.valid?
-        h.services << Service.create(:name => "s1", :status => "up", :host => h)
-        h.services << Service.create(:name => "s2", :status => "up", :host => h)
+        h.services << Noah::Service.create(:name => "s1", :status => "up", :host => h)
+        h.services << Noah::Service.create(:name => "s2", :status => "up", :host => h)
         h.save
       end
-      Services.all.size.should == 2
-      Services.all.first.name.should == "s1"
-      Services.all.last.name.should == "s2"
+      Noah::Services.all.size.should == 2
+      Noah::Services.all.first.name.should == "s1"
+      Noah::Services.all.last.name.should == "s2"
     end
 
   end
@@ -68,41 +68,41 @@ describe "Noah Service Model", :reset_redis => true do
     it "create a new Service when missing a Host" do
       servicename = "myservice1"
       servicestatus = "up"
-      service = Service.create(:name => servicename, :status => servicestatus)
+      service = Noah::Service.create(:name => servicename, :status => servicestatus)
       service.valid?.should == false
       service.errors.should == [[:host_id, :not_present]]
     end
 
     it "create a new Service when missing a name" do
-      host = Host.create(:name => "host1.domain.com", :status => "up")
+      host = Noah::Host.create(:name => "host1.domain.com", :status => "up")
       host.save
-      service = Service.create(:status => "up", :host => host)
+      service = Noah::Service.create(:status => "up", :host => host)
       service.valid?.should == false
       service.errors.should == [[:name, :not_present]]
     end
 
     it "create a new Service when missing a status" do
-      host = Host.create(:name => "host1.domain.com", :status => "up")
+      host = Noah::Host.create(:name => "host1.domain.com", :status => "up")
       host.save
-      service = Service.create(:name => 'foo', :host => host)
+      service = Noah::Service.create(:name => 'foo', :host => host)
       service.valid?.should == false
       service.errors.should == [[:status, :not_present], [:status, :not_member]]
     end
 
     it "create a new Service with an invalid status" do
-      host = Host.create(:name => "host1.domain.com", :status => "up")
+      host = Noah::Host.create(:name => "host1.domain.com", :status => "up")
       host.save
-      service = Service.create(:name => "myservice", :status => "invalid_status", :host => host)
+      service = Noah::Service.create(:name => "myservice", :status => "invalid_status", :host => host)
       service.valid?.should == false
       service.errors.should == [[:status, :not_member]]
     end
 
     it "create a duplicate Service" do
-      host = Host.create(:name => "host1.domain.com", :status => "up")
+      host = Noah::Host.create(:name => "host1.domain.com", :status => "up")
       host.save
-      s = Service.create(:name => "myservice", :status => "up", :host => host)
+      s = Noah::Service.create(:name => "myservice", :status => "up", :host => host)
       s.save
-      s1 = Service.create(:name => "myservice", :status => "up", :host => host)
+      s1 = Noah::Service.create(:name => "myservice", :status => "up", :host => host)
       s1.valid?.should == false
       s1.errors.should == [[[:name, :host_id], :not_unique]]
     end

data/spec/spec_helper.rb

@@ -1,19 +1,10 @@
-require 'bundler/setup'
-require 'ohm'
-begin
-  require 'yajl'
-rescue LoadError
-  require 'json'
-end
-
-ENV['RACK_ENV'] = 'test'
-ENV['REDIS_URL'] = 'redis://localhost:6379/3'
-Ohm::connect
-  
 require File.join(File.dirname(__FILE__), '..', 'lib', 'noah')
 require File.join(File.dirname(__FILE__), '..', 'lib', 'noah', 'app')
 require 'rspec'
 require 'rack/test'
+ENV['RACK_ENV'] = 'test'
+ENV['REDIS_URL'] = 'redis://localhost:6379/3'
+Ohm::connect
 
 RSpec.configure do |config|
   config.color_enabled = true
@@ -23,19 +14,19 @@ RSpec.configure do |config|
   config.after(:all, :populate_sample_data => true) {Ohm::redis.flushdb }
   config.before(:all, :populate_sample_data => true) do
     Ohm::redis.flushdb
-    h = Host.create(:name => 'localhost', :status => "up")
+    h = Noah::Host.create(:name => 'localhost', :status => "up")
     if h.save
       %w[redis noah].each do |service|
-        s = Service.create(:name => service, :status => "up", :host => h)
+        s = Noah::Service.create(:name => service, :status => "up", :host => h)
         h.services << s
       end
     end
 
-    a = Application.create(:name => 'noah')
+    a = Noah::Application.create(:name => 'noah')
     if a.save
-      cr = Configuration.create(:name => 'redis', :format => 'string', :body => 'redis://127.0.0.1:6379/0', :application => a)
-      ch = Configuration.create(:name => 'host', :format => 'string', :body => 'localhost', :application  => a)
-      cp = Configuration.create(:name => 'port', :format => 'string', :body => '9292', :application => a)
+      cr = Noah::Configuration.create(:name => 'redis', :format => 'string', :body => 'redis://127.0.0.1:6379/0', :application => a)
+      ch = Noah::Configuration.create(:name => 'host', :format => 'string', :body => 'localhost', :application  => a)
+      cp = Noah::Configuration.create(:name => 'port', :format => 'string', :body => '9292', :application => a)
       %w[cr ch cp].each do |c|
         a.configurations << eval(c)
       end
@@ -55,15 +46,15 @@ EOY
     }
 EOJ
 
-    a1 = Application.create(:name => 'myrailsapp1')
+    a1 = Noah::Application.create(:name => 'myrailsapp1')
     if a1.save
-      c1 = Configuration.create(:name => 'database.yml', :format => 'yaml', :body => my_yaml, :application => a1)
+      c1 = Noah::Configuration.create(:name => 'database.yml', :format => 'yaml', :body => my_yaml, :application => a1)
       a1.configurations << c1
     end
 
-    a2 = Application.create(:name => 'myrestapp1')
+    a2 = Noah::Application.create(:name => 'myrestapp1')
     if a2.save
-      c2 = Configuration.create(:name => 'config.json', :format => 'json', :body => my_json, :application => a2)
+      c2 = Noah::Configuration.create(:name => 'config.json', :format => 'json', :body => my_json, :application => a2)
       a2.configurations << c2
     end
   end

data/spec/support/test-redis.conf

@@ -0,0 +1,8 @@
+dir spec/support/db
+pidfile spec/support/db/redis.pid
+port 6379
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/spec/watcher_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Using the Watcher Model", :reset_redis => true do
+  before(:each) do
+    Ohm.redis.flushdb
+    @test_endpoint = "http://localhost/webhook"
+    @test_pattern = "/foo/bar"
+    Noah::Watcher.create :pattern => @test_pattern, :endpoint => @test_webhook
+    @test_watch = Noah::Watcher.new :endpoint => "http://localhost/webhook"
+  end
+  after(:each) do
+    #Ohm.redis.flushdb
+  end
+
+  describe "should" do
+    it "create a new Noah::Watcher" do
+      @test_watch.pattern = "/snarf"
+      @test_watch.valid?.should == true
+      @test_watch.save
+      a = Noah::Watcher.find(:endpoint => @test_watch.endpoint, :pattern => @test_watch.pattern).first
+      a.should == @test_watch
+    end
+    it "delete an existing Noah::Watcher" do
+      @test_watch.pattern = "/snarf"
+      @test_watch.save
+      @test_watch.delete
+      Noah::Watcher.find(:endpoint => @test_endpoint, :pattern => @test_pattern).first.should == nil
+    end
+  end
+
+  describe "should not" do
+    it "create a new Noah::Watcher with missing endpoint" do
+      a = Noah::Watcher.create(:pattern => "/foo/bar")
+      a.valid?.should == false
+      a.errors.should == [[:endpoint, :not_present]]
+    end
+    it "create a new Noah::Watcher with missing pattern" do
+      a = Noah::Watcher.create(:endpoint => "http://localhost/webhook")
+      a.valid?.should == false
+      a.errors.should == [[:pattern, :not_present]]
+    end
+    it "create a new Noah::Watcher with subset pattern" do
+      a = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah/")
+      b = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah/foobar")
+      b.valid?.should == false
+      b.errors.should == [[:pattern, :already_provided]]
+    end
+    it "create a new Noah::Watcher with superset pattern" do
+      a = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah/foobar")
+      b = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah")
+      b.valid?.should == false
+      b.errors.should == [[:pattern, :replaces_existing]]
+    end
+    it "create a duplicate Noah::Watcher" do
+      a = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah/foobar")
+      b = Noah::Watcher.create(:endpoint => "http://localhost.domain.com/webhook", :pattern => "//noah/foobar")
+      b.valid?.should == false
+      b.errors.should == [[[:endpoint, :pattern], :not_unique]]
+    end
+  end
+
+end