ember_cli_deploy_redis 0.1.0 → 1.0.0

data/lib/ember_cli_deploy_redis/web_helpers.rb

@@ -0,0 +1,162 @@
+require 'uri'
+
+module EmberCliDeployRedis
+  # This is not a public API
+  module WebHelpers
+    def strings(lang)
+      @@strings ||= {}
+      @@strings[lang] ||= begin
+        # Allow sidekiq-web extensions to add locale paths
+        # so extensions can be localized
+        settings.locales.each_with_object({}) do |path, global|
+          find_locale_files(lang).each do |file|
+            strs = YAML.load(File.open(file))
+            global.merge!(strs[lang])
+          end
+        end
+      end
+    end
+
+    def locale_files
+      @@locale_files = settings.locales.flat_map do |path|
+        Dir["#{path}/*.yml"]
+      end
+    end
+
+    def find_locale_files(lang)
+      locale_files.select { |file| file =~ /\/#{lang}\.yml$/ }
+    end
+
+    # This view helper provide ability display you html code in
+    # to head of page. Example:
+    #
+    #   <% add_to_head do %>
+    #     <link rel="stylesheet" .../>
+    #     <meta .../>
+    #   <% end %>
+    #
+    def add_to_head(&block)
+      @head_html ||= []
+      @head_html << block if block_given?
+    end
+
+    def display_custom_head
+      return unless defined?(@head_html)
+      @head_html.map { |block| capture(&block) }.join
+    end
+
+    # Simple capture method for erb templates. The origin was
+    # capture method from sinatra-contrib library.
+    def capture(&block)
+      block.call
+      eval('', block.binding)
+    end
+
+    # Given a browser request Accept-Language header like
+    # "fr-FR,fr;q=0.8,en-US;q=0.6,en;q=0.4,ru;q=0.2", this function
+    # will return "fr" since that's the first code with a matching
+    # locale in web/locales
+    def locale
+      @locale ||= begin
+        locale = 'en'.freeze
+        languages = request.env['HTTP_ACCEPT_LANGUAGE'.freeze] || 'en'.freeze
+        languages.downcase.split(','.freeze).each do |lang|
+          next if lang == '*'.freeze
+          lang = lang.split(';'.freeze)[0]
+          break locale = lang if find_locale_files(lang).any?
+        end
+        locale
+      end
+    end
+
+    def get_locale
+      strings(locale)
+    end
+
+    def t(msg, options={})
+      string = get_locale[msg] || msg
+      if options.empty?
+        string
+      else
+        string % options
+      end
+    end
+
+    def location
+      EmberCliDeployRedis.configuration.redis do |conn| conn.client.location end
+    end
+
+    def redis_connection
+      EmberCliDeployRedis.configuration.redis do |conn| conn.client.id end
+    end
+
+    def namespace
+      @@ns ||= EmberCliDeployRedis.configuration.redis do |conn|
+        conn.respond_to?(:namespace) ? conn.namespace : nil
+      end
+    end
+
+    def redis_info
+      EmberCliDeployRedis.configuration.redis do |conn|
+        # admin commands can't go through redis-namespace starting
+        # in redis-namespace 2.0
+        if conn.respond_to?(:namespace)
+          conn.redis.info
+        else
+          conn.info
+        end
+      end
+    end
+
+    def root_path
+      "#{env['SCRIPT_NAME']}/"
+    end
+
+    def relative_time(time)
+      %{<time datetime="#{time.getutc.iso8601}">#{time}</time>}
+    end
+
+    def csrf_tag
+      "<input type='hidden' name='authenticity_token' value='#{session[:csrf]}'/>"
+    end
+
+    def h(text)
+      ::Rack::Utils.escape_html(text)
+    rescue ArgumentError => e
+      raise unless e.message.eql?('invalid byte sequence in UTF-8')
+      text.encode!('UTF-16', 'UTF-8', invalid: :replace, replace: '').encode!('UTF-8', 'UTF-16')
+      retry
+    end
+
+    # Any paginated list that performs an action needs to redirect
+    # back to the proper page after performing that action.
+    def redirect_with_query(url)
+      r = request.referer
+      if r && r =~ /\?/
+        ref = URI(r)
+        redirect("#{url}?#{ref.query}")
+      else
+        redirect url
+      end
+    end
+
+    def product_version
+      "ember_cli_deploy_redis-ruby v#{EmberCliDeployRedis::VERSION}"
+    end
+
+    def redis_connection_and_namespace
+      @redis_connection_and_namespace ||= begin
+        namespace_suffix = namespace == nil ? '' : "##{namespace}"
+        "#{redis_connection}#{namespace_suffix}"
+      end
+    end
+
+    def revision_specifier_query_param
+      EmberCliDeployRedis.configuration.revision_specifier_query_param
+    end
+
+    def revision_test_url(revision)
+      "/?#{revision_specifier_query_param}[#{revision.application.name}]=#{revision.name}"
+    end
+  end
+end

data/spec/lib/ember_cli_deploy_redis/application_spec.rb

@@ -16,8 +16,18 @@ describe EmberCliDeployRedis::Application do
 
   describe '.latest_revision' do
     subject { application.latest_revision }
-    it 'returns Revision.latest_from_redis' do
-      expect(EmberCliDeployRedis::Revision).to receive(:latest_from_redis)
+    it 'returns Revision.active_from_redis' do
+      expect(EmberCliDeployRedis::Revision).to receive(:active_from_redis)
+        .with(application)
+        .and_return(:whatever)
+      expect(subject).to eq(:whatever)
+    end
+  end
+
+  describe '.active_revision' do
+    subject { application.active_revision }
+    it 'returns Revision.active_from_redis' do
+      expect(EmberCliDeployRedis::Revision).to receive(:active_from_redis)
         .with(application)
         .and_return(:whatever)
       expect(subject).to eq(:whatever)

data/spec/lib/ember_cli_deploy_redis/revision_list_spec.rb

@@ -5,9 +5,40 @@ describe EmberCliDeployRedis::RevisionList do
   let(:application) { double('application', name: 'app_name') }
   let(:revisions) { %w(one two three) }
 
-  it { is_expected.to delegate_method(:[]).to(:revisions) }
-  it { is_expected.to delegate_method(:first).to(:revisions) }
-  it { is_expected.to delegate_method(:last).to(:revisions) }
+  describe '#[]' do
+    it 'delegates to the revisions array' do
+      expect(revisions).to receive(:[]).and_call_original
+      expect(subject[0]).to eq('one')
+    end
+  end
+
+  describe '#first' do
+    it 'delegates to the revisions array' do
+      expect(revisions).to receive(:first).and_call_original
+      expect(subject.first).to eq('one')
+    end
+  end
+
+  describe '#last' do
+    it 'delegates to the revisions array' do
+      expect(revisions).to receive(:last).and_call_original
+      expect(subject.last).to eq('three')
+    end
+  end
+
+  describe '#each' do
+    it 'delegates to the revisions array' do
+      expect(revisions).to receive(:each).and_call_original
+      expect(subject.each(&:to_s)).to eq(revisions)
+    end
+  end
+
+  describe '#map' do
+    it 'delegates to the revisions array' do
+      expect(revisions).to receive(:map).and_call_original
+      expect(subject.map(&:to_s)).to eq(revisions)
+    end
+  end
 
   describe '#initialize' do
     it 'stores the application' do

data/spec/lib/ember_cli_deploy_redis/revision_spec.rb

@@ -3,22 +3,39 @@ require 'spec_helper'
 describe EmberCliDeployRedis::Revision do
   let(:application) { double('application', name: 'app_name') }
 
-  describe '.latest_from_redis' do
-    let(:latest_revision_name) { 'latest_revision' }
-    let(:do_the_thing) { described_class.latest_from_redis(application) }
+  describe '.active_from_redis' do
+    let(:active_revision_name) { 'active_revision' }
+    let(:do_the_thing) { described_class.active_from_redis(application) }
     before do
-      allow(described_class).to receive(:latest_revision_from_redis)
-        .and_return(latest_revision_name)
+      allow(described_class).to receive(:active_revision_from_redis)
+        .and_return(active_revision_name)
     end
-    it 'gets the latest_revision_from_redis and calls Revision.new with it' do
-      expect(described_class).to receive(:new).with(application, latest_revision_name)
-      expect(described_class).to receive(:latest_revision_from_redis).with(application)
+    it 'gets the active_revision_from_redis and calls Revision.new with it' do
+      expect(described_class).to receive(:new).with(application, active_revision_name)
+      expect(described_class).to receive(:active_revision_from_redis).with(application)
       do_the_thing
     end
   end
 
-  describe '.latest_revision_from_redis' do
-    subject { described_class.latest_revision_from_redis(application) }
+  describe '#activate!' do
+    subject { described_class.new(application, 'new_revision') }
+    let(:do_the_thing) { subject.activate! }
+    let(:application) { EmberCliDeployRedis::Application.new('application_name') }
+    it 'makes the revision active' do
+      do_the_thing
+      expect(application.active_revision).to eq(subject)
+    end
+    it 'leaves the other revision in existence' do
+      described_class.new(application, 'old_revision').activate!
+      do_the_thing
+      old_revision = application.revision_by_name('old_revision')
+      expect(old_revision).to be_kind_of(EmberCliDeployRedis::Revision)
+      expect(old_revision).to_not be_active
+    end
+  end
+
+  describe '.active_revision_from_redis' do
+    subject { described_class.active_revision_from_redis(application) }
     let(:redis_key) { 'revision_list' }
     let(:most_recent_revision) { 'recent' }
     let(:oldest_revision) { 'oldest' }
@@ -41,8 +58,8 @@ describe EmberCliDeployRedis::Revision do
       end
     end
     context 'with no deployed revisions' do
-      it 'raises an error' do
-        expect { subject }.to raise_error
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
   end

data/spec/lib/ember_cli_deploy_redis/web_helpers_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'ember_cli_deploy_redis/web_helpers'
+
+describe EmberCliDeployRedis::WebHelpers do
+  let(:described_class) {
+    Class.new do
+      include EmberCliDeployRedis::WebHelpers
+    end
+  }
+  before do
+    allow(subject).to receive(:request).and_return(request)
+    allow(subject).to receive(:settings).and_return(settings)
+  end
+  let(:request) { double('request', env: request_env) }
+  let(:request_env) { {} }
+  let(:settings) { double('request', locales: settings_locales) }
+  let(:settings_locales) { ['web/locales'] }
+
+  describe '#locale' do
+    context 'without an Accept-Language header' do
+      it 'uses the default locale' do
+        expect(subject.locale).to eq('en')
+      end
+    end
+    context 'with an Accept-Language header' do
+      let(:request_env) { { 'HTTP_ACCEPT_LANGUAGE' => accept_language } }
+
+      context 'starting with fr' do
+        let(:accept_language) { 'fr-FR,fr;q=0.8,en-US;q=0.6,en;q=0.4,ru;q=0.2' }
+        it 'returns the correct locale' do
+          pending "We have not localized for French."
+          expect(subject.locale).to eq('fr')
+        end
+      end
+      context 'starting with zh-cn' do
+        let(:accept_language) { 'zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4,ru;q=0.2' }
+        it 'returns the correct locale' do
+          pending "We have not localized for Chinese."
+          expect(subject.locale).to eq('zh-cn')
+        end
+      end
+      context 'starting with nb' do
+        let(:accept_language) { 'nb-NO,nb;q=0.2' }
+        it 'returns the correct locale' do
+          pending "We have not localized for Norwegian."
+          expect(subject.locale).to eq('nb')
+        end
+      end
+      context "for a language we don't have (cause it doesn't exist)" do
+        let(:accept_language) { 'zz,zz;q=0.2' }
+        it 'defaults to en' do
+          expect(subject.locale).to eq('en')
+        end
+      end
+      context 'starting with en' do
+        let(:accept_language) { 'en-us; *' }
+        it 'returns the correct locale' do
+          expect(subject.locale).to eq('en')
+        end
+      end
+      context 'containing no guidance' do
+        let(:accept_language) { '*' }
+        it 'defaults to en' do
+          expect(subject.locale).to eq('en')
+        end
+      end
+    end
+  end
+end

data/spec/lib/ember_cli_deploy_redis/web_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'ember_cli_deploy_redis/web'
+require 'rack/test'
+require 'rspec-html-matchers'
+# require 'tilt/erubis'
+
+describe EmberCliDeployRedis::Web do
+  include Rack::Test::Methods
+  include RSpecHtmlMatchers
+
+  def app
+    described_class
+  end
+
+  let(:application1) { EmberCliDeployRedis::Application.new('application1') }
+  let(:app1_revision_a) { EmberCliDeployRedis::Revision.new(application1, 'app1_revision_a') }
+  let(:app1_revision_b) { EmberCliDeployRedis::Revision.new(application1, 'app1_revision_b') }
+  let(:application2) { EmberCliDeployRedis::Application.new('application2') }
+  let(:app2_revision_a) { EmberCliDeployRedis::Revision.new(application2, 'app2_revision_a') }
+  let(:app2_revision_b) { EmberCliDeployRedis::Revision.new(application2, 'app2_revision_b') }
+
+  describe 'GET /' do
+    let(:the_request) { get '/' }
+    before do
+      EmberCliDeployRedis.configure do |config|
+        config.web_application_names = %w(application1 application2)
+      end
+      app1_revision_b.activate!
+      app1_revision_a.activate!
+      app2_revision_b.activate!
+      app2_revision_a.activate!
+      app2_revision_b.activate!
+    end
+
+    it 'responds with Success' do
+      the_request
+      expect(last_response).to be_ok
+    end
+    it 'includes a row for each application' do
+      the_request
+      expect(last_response.body).to have_tag('tr') do
+        with_tag 'td.col-application a', href: '/applications/application1', text: 'application1'
+        with_tag 'td.col-current-revision', text: /app1_revision_a/
+      end
+      expect(last_response.body).to have_tag('tr') do
+        with_tag 'td.col-application a', href: '/applications/application2', text: 'application2'
+        with_tag 'td.col-current-revision', text: /app2_revision_b/
+      end
+    end
+  end
+
+  describe 'GET /applications/:app_name' do
+    let(:the_request) { get "/applications/application1" }
+
+    before do
+      app1_revision_b.activate!
+      app1_revision_a.activate!
+      app1_revision_b.activate!
+    end
+
+    it 'responds with Success' do
+      the_request
+      expect(last_response).to be_ok
+    end
+    it 'includes a row for each revision' do
+      the_request
+      expect(last_response.body).to have_tag('tr') do
+        with_tag 'td.col-revision', text: /app1_revision_b/
+      end
+      expect(last_response.body).to have_tag('tr') do
+        with_tag 'td.col-revision', text: /app1_revision_a/
+      end
+      expect(last_response.body).to have_tag('tr') do
+        with_tag 'td.col-revision', text: /app1_revision_b/
+      end
+    end
+    it 'shows the correct revisions as Active' do
+      the_request
+      expect(last_response.body).to have_tag('tr.revision-app1_revision_b') do
+        with_tag 'td.col-status', text: /\A\s*Active\s*\z/
+      end
+    end
+    it 'does not show the inactive revisions as Active' do
+      the_request
+      expect(last_response.body).to have_tag('tr.revision-app1_revision_a') do
+        without_tag 'td.col-status', text: /\A\s*Active\s*\z/
+      end
+    end
+    it 'has a Make Active button on non-active revisions' do
+      the_request
+      expect(last_response.body).to have_tag(
+        'tr.revision-app1_revision_a td.col-status form',
+        method: 'post',
+        action: '/applications/application1/activate/app1_revision_a',
+      ) do
+        with_tag 'input', value: /Make Active/i
+      end
+    end
+    it 'does not have a Make Active button on active revisions' do
+      the_request
+      expect(last_response.body).to have_tag('tr.revision-app1_revision_b') do
+        without_tag 'td.col-status form'
+      end
+    end
+    context 'without a configured revision_specifier_query_param' do
+      it 'does not have a Test link for any revision' do
+        the_request
+        expect(last_response.body).to_not have_tag('td.col-status a', text: /test this revision/i)
+      end
+    end
+    context 'with a configured revision_specifier_query_param' do
+      before do
+        EmberCliDeployRedis.configure do |config|
+          config.revision_specifier_query_param = '_specified_revision'
+        end
+      end
+      it 'has a Test link for each non-active revision' do
+        the_request
+        expect(last_response.body).to have_tag(
+          'tr.revision-app1_revision_a td.col-revision a',
+          text: /test this revision/i,
+          href: '/?_specified_revision[application1]=app1_revision_a',
+        )
+      end
+      it 'does not have a Test link for active revisions' do
+        the_request
+        expect(last_response.body).to have_tag('tr.revision-app1_revision_b') do
+          without_tag 'td.col-status a', text: /test this revision/i
+        end
+      end
+    end
+  end
+
+  describe 'POST /applications/:app_name/activate/:revision_name' do
+    let(:the_request) { post "/applications/application1/activate/app1_revision_a" }
+
+    before do
+      app1_revision_a.activate!
+      app1_revision_b.activate!
+    end
+
+    it 'redirects to the application page' do
+      the_request
+      expect(last_response).to be_redirect
+      follow_redirect!
+      expect(last_request.url).to match %r(/applications/application1$)
+    end
+    it 'makes the revision active' do
+      the_request
+      expect(application1.active_revision).to eq(app1_revision_a)
+    end
+    it 'executes the configured on_revision_activated callback' do
+      callback_was_called = false
+      EmberCliDeployRedis.configure do |config|
+        config.on_revision_activated do |revision|
+          callback_was_called = true
+          expect(revision).to eq(app1_revision_a)
+        end
+      end
+      the_request
+      expect(callback_was_called).to be_truthy
+    end
+  end
+end