noms-command 0.5.0 → 2.1.1

data/lib/noms/command/version.rb

@@ -3,5 +3,5 @@ class NOMS
 end
 
 class NOMS::Command
-    VERSION = "0.5.0"
+    VERSION = "2.1.1"
 end

data/lib/noms/command/window.rb

@@ -54,11 +54,29 @@ class NOMS::Command::Window::Console < NOMS::Command::Base
 
     # Some implementations have a kind of format string. I don't
     def log(*items)
-        @log.debug(items.map { |s| _sanitize(s) }.join(', '))
+        @log.debug(items.map { |s| _string(s) }.join(', '))
     end
 
-    def _sanitize(s)
-        s.respond_to?(:to_str) ? s : s.to_json
+    def _string(s)
+        s = _sanitize(s)
+        s.kind_of?(Enumerable) ? s.to_json : s.inspect
+    end
+
+    # Get rid of V8 stuff
+    def _sanitize(thing)
+        # This really needs to go into a class
+        if thing.kind_of? V8::Array or thing.respond_to? :to_ary
+            thing.map do |item|
+                _sanitize item
+            end
+        elsif thing.respond_to? :keys
+            Hash[
+                 thing.keys.map do |key|
+                     [key, _sanitize(thing[key])]
+                 end]
+        else
+            thing
+        end
     end
 
 end

data/lib/noms/command/xmlhttprequest.rb

@@ -4,8 +4,6 @@ require 'noms/command/urinion'
 require 'noms/command/useragent'
 require 'noms/command/error'
 
-require 'httpclient'
-
 class NOMS
 
 end
@@ -113,7 +111,7 @@ class NOMS::Command::XMLHttpRequest
     end
 
     def HEADERS_RECEIVED
-       HEADERS_RECEIVED
+        HEADERS_RECEIVED
     end
 
     def LOADING
@@ -154,24 +152,26 @@ class NOMS::Command::XMLHttpRequest
         self.readyState = OPENED
         self.readyState = HEADERS_RECEIVED
         self.readyState = LOADING
-        @responseText = @response.content
+        @responseText = @response.body
         self.readyState = DONE
     end
 
     def status
-        @response.status.to_i unless @response.nil?
+        @response.status unless @response.nil?
     end
 
     def statusText
-        @response.status + ' ' + @response.reason unless @response.nil?
+        @response.statusText unless @response.nil?
     end
 
     def getResponseHeader(header)
-        @response.header[header.downcase] unless @response.nil?
+        @response.header header unless @response.nil?
     end
 
     def getAllResponseHeaders
-        lambda { || @response.headers.map { |h, v| "#{h}: #{v}" }.join("\n") + "\n" }
+        unless @response.nil?
+            lambda { || @response.header.map { |h, v| "#{h}: #{v}" }.join("\n") + "\n" }
+        end
     end
 
     def abort()

data/noms-command.gemspec

@@ -19,12 +19,14 @@ Gem::Specification.new do |spec|
 
     spec.add_runtime_dependency "therubyracer"
     spec.add_runtime_dependency "mime-types"
-    spec.add_runtime_dependency "httpclient"
+    spec.add_runtime_dependency "typhoeus"
     spec.add_runtime_dependency "json"
     spec.add_runtime_dependency "trollop"
     spec.add_runtime_dependency "highline"
+    spec.add_runtime_dependency "bcrypt"
 
     spec.add_development_dependency "bundler", "~> 1.7"
     spec.add_development_dependency "rake", "~> 10.0"
+    spec.add_development_dependency "rspec"
     spec.add_development_dependency "sinatra"
 end

data/spec/07js_spec.rb

@@ -67,7 +67,7 @@ describe NOMS::Command::Application do
                 app = make_script_app("console.log('test debug output')", :logger => log)
                 app.fetch!
                 app.render!
-                expect(logcatcher.string).to match(/^D,.*test debug output$/)
+                expect(logcatcher.string).to match(/^D,.*test debug output/)
             end
 
         end

data/spec/10auth_spec.rb

@@ -2,6 +2,138 @@
 
 require 'spec_helper'
 
+require 'digest/sha1'
+
+require 'noms/command/application'
+require 'noms/command/auth'
+
+describe NOMS::Command::Auth::Identity do
+
+    before(:all) do
+        setup_fixture
+        NOMS::Command::Auth::Identity.identity_dir = 'test/identities'
+        File.chmod 0600, 'test/identity'
+        FileUtils.rm_r 'test/identities' if File.directory? 'test/identities'
+        File.unlink 'test/identities/.noms-vault-key' if File.exist? 'test/identities/.noms-vault-key'
+    end
+
+    after(:all) do
+        teardown_fixture
+    end
+
+    before(:each) do
+        @identity = NOMS::Command::Auth::Identity.new({ 'id' => 'Authorization+Required=http://localhost:8787/',
+                                                          'data' => 'testdata' })
+        identity_file = File.join(NOMS::Command::Auth::Identity.identity_dir, @identity.id_number)
+        @vault_keyfile = File.join(NOMS::Command::Auth::Identity.identity_dir, '.noms-vault-key')
+        File.unlink "#{identity_file}.json" if File.exist? "#{identity_file}.json"
+        File.unlink "#{identity_file}.enc" if File.exist? "#{identity_file}.json"
+        File.unlink @vault_keyfile if File.exist? @vault_keyfile
+    end
+
+    describe '.new' do
+
+        it "should create an identity" do
+            identity = NOMS::Command::Auth::Identity.new({'id' => 'Authorization+Required=http://localhost:8787/',
+                                                             'data' => 'testdata' })
+            expect(identity).to be_a NOMS::Command::Auth::Identity
+        end
+
+    end
+
+    describe "#id_number" do
+
+        it "should return the hash of the identity id" do
+            comp_id = Digest::SHA1.new.update(@identity['id']).hexdigest
+            expect(@identity.id_number).to eq comp_id
+        end
+
+    end
+
+    describe "#save" do
+
+        it "should save the identity in an encrypted file" do
+            file = @identity.save
+            expect(File.basename(file)).to eq @identity.id_number + '.enc'
+            expect(File.exist? file).to be_truthy
+            expect(File.read file).to_not match(/Authorization/)
+            expect(File.exist? File.join(NOMS::Command::Auth::Identity.identity_dir, '.noms-vault-key')).to be_truthy
+        end
+
+        it "should save unencrypted when directed" do
+            file = @identity.save :encrypt => false
+            expect(File.basename(file)).to eq @identity.id_number + '.json'
+            expect(File.read file).to match(/Authorization/)
+        end
+
+        it "should save in specific file when asked" do
+            file = @identity.save :file => 'test/identities/test-identity.json', :encrypt => false
+            expect(File.basename(file)).to eq 'test-identity.json'
+            expect(File.read file).to match(/Authorization/)
+        end
+
+        it "should not save when from specified file" do
+            this_identity = NOMS::Command::Auth::Identity.from 'test/identity'
+            file = this_identity.save :file => 'test/identities/test-identity.enc'
+            expect(file).to eq 'test/identity'
+        end
+
+    end
+
+    describe '.saved' do
+
+        it 'should be false when not saved' do
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_falsey
+        end
+
+        it 'should be true when saved' do
+            file = @identity.save
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_truthy
+        end
+
+        it 'should be false when not decryptable' do
+            file = @identity.save
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_truthy
+
+            File.unlink NOMS::Command::Auth::Identity.vault_keyfile
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_falsey
+        end
+
+        it 'should be false when too old' do
+            file = @identity.save
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_truthy
+            old_hash = Digest::SHA1.new.update(File.read @vault_keyfile).hexdigest
+
+            old_ts = Time.now - 24 * 3600
+            File.utime(old_ts, old_ts, @vault_keyfile)
+            expect(NOMS::Command::Auth::Identity.saved @identity['id']).to be_falsey
+            new_hash = Digest::SHA1.new.update(File.read @vault_keyfile).hexdigest
+            expect(new_hash).to_not eq old_hash
+        end
+
+        it 'should load an identity' do
+            file = @identity.save
+
+            id_data = NOMS::Command::Auth::Identity.saved @identity['id']
+            expect(id_data['id']).to eq @identity['id']
+        end
+
+        it 'should update vault key mtime' do
+            file = @identity.save
+
+            old_ts = Time.now - (5 * 60)
+            File.utime(old_ts, old_ts, @vault_keyfile)
+
+            id_data = NOMS::Command::Auth::Identity.saved @identity['id']
+            new_identity = NOMS::Command::Auth::Identity.new(id_data)
+            new_ts = File.stat(@vault_keyfile).mtime
+            expect(Time.now - new_ts).to be < 5
+        end
+
+    end
+
+end
+
 describe "NOMS::Command::Application" do
 
     before(:all) do

data/spec/11useragent_cache_spec.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'noms/command/useragent'
+
+describe 'NOMS::Command::UserAgent' do
+    before(:all) do
+        setup_fixture
+        start_server
+    end
+
+    after(:all) do
+        stop_server
+        teardown_fixture
+    end
+
+    context 'when caching' do
+
+        describe '.request' do
+
+            before(:each) do
+                @ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :max_age => 10, :cache => true
+                @ua.clear_cache!
+            end
+
+            it 'loads fresh content' do
+                response, = @ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response.from_cache?).to be_falsey
+                generated = get_generated(response)
+                expect(Time.now - generated).to be <= 1
+            end
+
+            it 'loads cached content' do
+                response0, = @ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 2
+                response1, = @ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response1.from_cache?).to be_truthy
+                generated1 = get_generated response1
+
+                expect(generated1).to eq generated0
+            end
+
+            it 'refetches cached content' do
+                response0, = @ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 5
+                response1, = @ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response1.from_cache?).to be_falsey
+                generated1 = get_generated response1
+
+                expect(Time.now - generated1).to be <= 1
+            end
+
+            it 'revalidates cached content with last-modified' do
+                response0, = @ua.request('GET', 'http://localhost:8787/static/last-modified')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 5
+                response1, = @ua.request('GET', 'http://localhost:8787/static/last-modified')
+                expect(response1.from_cache?).to be_truthy
+                generated1 = get_generated response1
+
+                expect(generated1).to eq generated0
+            end
+
+            it 'revalidates cached content' do
+                response0, = @ua.request('GET', 'http://localhost:8787/static/expires-2-constant')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 3
+                response1, = @ua.request('GET', 'http://localhost:8787/static/expires-2-constant')
+                expect(response1.from_cache?).to be_truthy
+                generated1 = get_generated response1
+
+                expect(generated1).to eq generated0
+            end
+
+            it 'refuses to cache longer than :max_age' do
+                response0, = @ua.request('GET', 'http://localhost:8787/static/long-cache')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 5
+                response1, = @ua.request('GET', 'http://localhost:8787/static/long-cache')
+                expect(response1.from_cache?).to be_truthy
+                generated1 = get_generated response1
+
+                expect(generated1).to eq generated0
+
+                sleep 6
+                response2, = @ua.request('GET', 'http://localhost:8787/static/long-cache')
+                expect(response2.from_cache?).to be_falsey
+                generated2 = get_generated response2
+
+                expect(generated2 - Time.now).to be <= 1
+            end
+
+            it 'refuses to cache when directed' do
+                ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :cache => false
+                response0, = ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 2
+                response1, = ua.request('GET', 'http://localhost:8787/static/expires-4')
+                expect(response1.from_cache?).to be_falsey
+                generated1 = get_generated response1
+
+                expect(generated1).to_not eq generated0
+                expect(generated0 - Time.now).to be <= 1
+            end
+
+            it 'does not serve cached reply for authenticated pages, when unauthenticated' do
+                File.chmod 0600, 'test/identity'
+                File.open('test/fail-identity', 'w') do |outfh|
+                    outfh.write JSON.pretty_generate(File.open('test/identity') { |fh| JSON.load(fh) }.merge({ 'password' => 'FAIL' }))
+                end
+                File.chmod 0600, 'test/fail-identity'
+
+                ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :cache => true,
+                     :specified_identities => ['test/identity']
+
+                response0, = ua.request('GET', 'http://localhost:8787/auth/cacheable')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :cache => true,
+                    :specified_identities => ['test/fail-identity']
+                response1, = ua.request('GET', 'http://localhost:8787/auth/cacheable')
+                expect(response1.from_cache?).to be_falsey
+                expect(response1.status).to eq 401
+            end
+
+            it 'does serve cached reply for authenticated pages, when authenticated' do
+                File.chmod 0600, 'test/identity'
+                ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :cache => true,
+                    :specified_identities => ['test/identity']
+                response0, = ua.request('GET', 'http://localhost:8787/auth/cacheable')
+                expect(response0.from_cache?).to be_falsey
+                generated0 = get_generated response0
+
+                sleep 3
+                response1, = ua.request('GET', 'http://localhost:8787/auth/cacheable')
+                expect(response1.from_cache?).to be_falsey
+                generated1 = get_generated response1
+                expect(Time.now - generated1).to be < 1
+            end
+        end
+
+    end
+
+end

data/spec/12useragent_auth_cookie_spec.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'noms/command/useragent'
+
+describe NOMS::Command::UserAgent do
+
+    before(:all) do
+        setup_fixture
+        start_server
+    end
+
+    after(:all) do
+        teardown_fixture
+        stop_server
+    end
+
+    context 'when using cookies' do
+
+        describe '#request' do
+
+            before(:each) do
+                @cookie_jar = File.join(NOMS::Command.home, 'cookies.txt')
+                File.unlink @cookie_jar if File.exist? @cookie_jar
+                @ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :specified_identities => ['test/identity'],
+                    :cache => false
+            end
+
+            it 'gets cookie-authorized document' do
+                response, = @ua.get 'http://localhost:8787/cookie/home'
+                result = JSON.parse(response.body)
+                expect(result['cookie_user']).to eq 'testuser'
+            end
+
+            it 'persists cookies between invocations' do
+                response0, = @ua.get 'http://localhost:8787/cookie/home'
+                result0 = JSON.parse(response0.body)
+
+                expect(File.exist? @cookie_jar).to be_truthy
+
+                ua = NOMS::Command::UserAgent.new 'http://localhost:8787/', :cache => false
+                response1, = ua.get 'http://localhost:8787/cookie/home'
+                result1 = JSON.parse(response1.body)
+
+                expect(result1).to have_key 'cookie_user'
+                expect(result1['cookie_user']).to eq 'testuser'
+            end
+        end
+
+    end
+
+end