marty 1.0.44 → 1.0.46

data/lib/marty/schema_helper.rb

@@ -25,6 +25,47 @@ class Marty::SchemaHelper
   end
 
   # if conds is true, var_array columns we be required
+  delorean_fn :disallow_if_conds, sig: [2, 20] do
+    |var_array, *conds_array|
+    {"anyOf"=>[{"not"=>{"allOf"=> conds_array}},
+               {"properties"=> var_array.each_with_object({}) do
+                  |v,h|
+                  h[v] = { "not" => {} }
+                end
+               }]}
+  end
+
+
+  # if param is present, disallow cols
+  delorean_fn :disallow_if_present, sig: [2, 20] do
+    |dep_column, *var_array|
+    dep_check(dep_column,
+              {"properties"=> var_array.each_with_object({}) do
+                 |v,h|
+                 h[v] = { "not" => {} }
+               end
+              })
+  end
+
+  # if param is not present, disallow cols
+  # note: small problem, probably not fixable:
+  #  if this condition fails (i.e. dep_column is not present,
+  #  but var(s) in var_array are are present)
+  #  it will report both the required clause and the not clauses
+  #  as failed.   so the caller will see a message that a
+  #  required field is missing (which is not really a required field)
+  delorean_fn :disallow_if_not_present, sig: [2, 20] do
+    |dep_column, *var_array|
+    { "anyOf" => [
+        {"required" => [dep_column] },
+        {"properties"=> var_array.each_with_object({}) do
+           |v,h|
+           h[v] = { "not" => {} }
+         end
+        }]}
+  end
+
+  # if conds is true, var_array columns are not allowed
   delorean_fn :required_if, sig: [2, 20] do
     |var_array, *conds_array|
     {"anyOf"=>[{"not"=>{"allOf"=> conds_array}},

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.0.44"
+  VERSION = "1.0.46"
 end

data/spec/controllers/diagnostic_controller_spec.rb

@@ -1,102 +1,192 @@
 require 'spec_helper'
-
 module Marty
   RSpec.describe DiagnosticController, type: :controller do
     before(:each) { @routes = Marty::Engine.routes }
     let(:json_response) { JSON.parse(response.body) }
 
-    describe 'GET #index' do
-      it 'returns http success' do
-        get :index, testop: :version
-
-        expect(response).to have_http_status(:success)
-      end
-
-      it 'returns the current version' do
-        get :index, testop: :version
+    def version
+      {"Git"      => "",
+       "Marty"    => Marty::VERSION,
+       "Delorean" => Delorean::VERSION,
+       "Mcfly"    => Mcfly::VERSION}
+    end
 
-        aggregate_failures do
-          expect(assigns('details').count).to eq(3)
-          expect(assigns('details').third.methods)
-            .to include(:name, :status, :description)
-          expect(assigns('details').third.description).to eq(Marty::VERSION)
-        end
-      end
+    def environment
+      rbv = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+      {'Environment'             => Rails.env,
+       'Rails'                   => Rails.version,
+       'Netzke Core'             => Netzke::Core::VERSION,
+       'Netzke Basepack'         => Netzke::Basepack::VERSION,
+       'Ruby'                    => rbv,
+       'RubyGems'                => Gem::VERSION,
+       'Database Adapter'        => described_class::Database.db_adapter_name,
+       'Database Server'         => described_class::Database.db_server_name,
+       'Database Version'        => described_class::Database.db_version,
+       'Database Schema Version' => described_class::Database.db_schema}
+    end
 
-      it 'returns the appropriate json' do
-        get :index, {format: :json, testop: :version}
+    def version_display
+      <<-ERB
+      <h3>Version</h3>
+      <div class="wrapper">
+      <table>
+        <th class=""><small>consistent</small></th>
+        <th class=""></th>
+        <tr class="passed">
+          <td>Git</td>
+          <td class="overflow"></td>
+        </tr>
+        <tr class="passed">
+          <td>Marty</td>
+          <td class="overflow">#{Marty::VERSION}</td>
+        </tr>
+        <tr class="passed">
+          <td>Delorean</td>
+          <td class="overflow">#{Delorean::VERSION}</td>
+        </tr>
+        <tr class="passed">
+          <td>Mcfly</td>
+          <td class="overflow">#{Mcfly::VERSION}</td>
+        </tr>
+      </table>
+      </div>
+      ERB
+    end
 
-        aggregate_failures do
-          expect(json_response.first['diag_count']).to eq(3)
-          expect(json_response.first['error_count']).to eq(0)
-          expect(json_response
-                 .find { |d| d['name'] == 'Marty Version' }['description'])
-            .to eq(Marty::VERSION)
-        end
-      end
+    def version_display_fail val
+      <<-ERB
+      <h3>Version</h3>
+      <h3 class="error"> &#x26a0; Issues Detected </h3>
+      <div class="wrapper">
+      <table>
+        <th class="error">node1</th>
+        <th class="error"></th>
+        <tr class="passed">
+          <td>Git</td>
+          <td class="overflow"></td>
+        </tr>
+        <tr class="passed">
+          <td>Marty</td>
+          <td class="overflow">#{Marty::VERSION}</td>
+        </tr>
+        <tr class="passed">
+          <td>Delorean</td>
+          <td class="overflow">#{Delorean::VERSION}</td>
+        </tr>
+        <tr class="passed">
+          <td>Mcfly</td>
+          <td class="overflow">#{Mcfly::VERSION}</td>
+        </tr>
+      </table>
+      <table>
+        <th class="error">node2</th>
+        <th class="error"></th>
+        <tr class="passed">
+          <td>Git</td>
+          <td class="overflow"></td>
+        </tr>
+        <tr class="passed">
+          <td>Marty</td>
+          <td class="overflow">#{val}</td>
+        </tr>
+        <tr class="passed">
+          <td>Delorean</td>
+          <td class="overflow">#{Delorean::VERSION}</td>
+        </tr>
+        <tr class="passed">
+          <td>Mcfly</td>
+          <td class="overflow">#{Mcfly::VERSION}</td>
+        </tr>
+      </table>
+      </div>
+      ERB
     end
 
-    describe 'GET #version' do
-      it 'returns http success' do
-        get :version
+    def minimize(str)
+      str.gsub(/\s+/, "")
+    end
 
+    describe 'GET #op' do
+      it 'returns http success with local scope' do
+        get :op, op: 'version', scope: 'local'
         expect(response).to have_http_status(:success)
       end
 
-      it 'returns the current version' do
-        get :version
+      it 'returns the current version JSON' do
+        get :op, format: :json, op: 'version', scope: 'local'
+        expect(assigns('result')).to eq(version)
+      end
 
-        aggregate_failures do
-          expect(assigns('details').count).to eq(3)
-          expect(assigns('details').third.methods)
-            .to include(:name, :status, :description)
-          expect(assigns('details').third.description).to eq(Marty::VERSION)
-        end
+      it 'returns the correct environment JSON' do
+        get :op, format: :json, op: 'environment', scope: 'local'
+        expect(assigns('result')).to eq(environment)
       end
 
-      it 'returns the appropriate json' do
-        get :version, format: :json
+      it 'produces an html display of the diagnostic (version)' do
+        test = described_class::Version.display({'stub' => version})
+        expect(minimize(test)).to eq(minimize(version_display))
+      end
 
-        aggregate_failures do
-          expect(json_response.first['diag_count']).to eq(3)
-          expect(json_response.first['error_count']).to eq(0)
-          expect(json_response
-                 .find { |d| d['name'] == 'Marty Version' }['description'])
-            .to eq(Marty::VERSION)
-        end
+      it 'masks consistent nodes for display (version)' do
+        data = {'node1' => version, 'node2' => version}
+        test = described_class::Version.display(data)
+        expect(minimize(test)).to eq(minimize(version_display))
       end
-    end
 
-    describe 'GET #environment' do
-      it 'returns http success' do
-        get :environment
+      it 'displays all nodes when there is an inconsistent node (version)' do
+        ver       = '0.0.0'
+        data      = {'node1' => version, 'node2' => version + {'Marty' => ver}}
+        expected  = version_display_fail(ver)
+        test      = described_class::Version.display(data)
+        expect(minimize(expected)).to eq(minimize(test))
+      end
+    end
 
-        expect(response).to have_http_status(:success)
+    describe 'diagnostic classes and aggregate functions' do
+      it 'has access to DiagnosticController request' do
+        get :op, op: 'version', scope: 'local'
+        expect(described_class::Base.request).not_to eq(nil)
       end
 
-      it 'returns the environment details' do
-        get :environment
+      it 'can aggregate diagnostics and return appropriate JSON' do
+        # simulate open-uri nodal diag request
+        uri_stub = {:open => nil, :readlines => [version.to_json]}
+        nodes    = ['node1', 'node2', 'node3']
+        expected = nodes.each_with_object({}){|n, h| h[n] = version}
 
+        # mock nodes and diag request to node
+        allow(described_class::Base.request).to receive(:port).and_return(nil)
+        allow(described_class::Base).to receive(:get_nodes).and_return(nodes)
+        allow(described_class::Base).to receive_message_chain(uri_stub)
+
+        # perform aggregation using Base class function and Version class
+        expect(described_class::Base.get_nodal_diags('version')).to eq(expected)
+        expect(described_class::Version.aggregate).to eq(expected)
+      end
+
+      # returns true if there are differences in nodes for Base/Version
+      it 'determines diff of aggregate diagnostic' do
+        inconsistent = {'1' => version, '2' => version + {'Git' => '123'}}
+        consistent = inconsistent + {'2' => version}
         aggregate_failures do
-          expect(assigns('details').count).to eq(9)
-          expect(assigns('details').first.methods)
-            .to include(:name, :status, :description)
-          expect(assigns('details').first.description).to eq('test')
+          expect(described_class::Base.diff(inconsistent)).to eq(true)
+          expect(described_class::Base.diff(consistent)).to eq(false)
+          expect(described_class::Version.diff(inconsistent)).to eq(true)
+          expect(described_class::Version.diff(consistent)).to eq(false)
         end
       end
 
-      it 'returns the appropriate json' do
-        get :environment, format: :json
-
+      it 'can detects errors in diagnostic' do
+        error_free = version
+        error_test = version + {'Git' => described_class::Base.
+                                           error('Failed accessing git')}
         aggregate_failures do
-          expect(json_response.first['diag_count']).to eq(9)
-          expect(json_response.first['error_count']).to eq(0)
-          expect(json_response
-                 .find { |d| d['name'] == 'Environment' }['description'])
-            .to eq('test')
+          expect(described_class::Base.errors(error_free)).to eq(0)
+          expect(described_class::Base.errors(error_test)).to eq(1)
+          expect(described_class::Version.errors(error_free)).to eq(0)
+          expect(described_class::Version.errors(error_test)).to eq(1)
         end
       end
     end
-
   end
 end

data/spec/controllers/rpc_controller_spec.rb

@@ -259,12 +259,13 @@ eof
 script10_schema = <<eof
 A:
     properties = {
-              "opt1" :     { "type" : "string" },
-              "opttf" :    { "type" : "boolean" },
-              "opttrue" :  { "type" : "string" },
-              "optfalse" : { "type" : "string" },
-              "req1" :     { "pg_enum" : "CondEnum" },
-              "req2" :     { "pg_enum" : "CondEnum" }
+              "opt1" :        { "type" : "string" },
+              "opttf" :       { "type" : "boolean" },
+              "opttrue" :     { "type" : "string" },
+              "optfalse" :    { "type" : "string" },
+              "optdisallow" : { "type" : "string" },
+              "req1" :        { "pg_enum" : "CondEnum" },
+              "req2" :        { "pg_enum" : "CondEnum" }
          }
 
     req1_is_opt1 = Marty::SchemaHelper.enum_is('req1', ['opt1'])
@@ -290,11 +291,22 @@ A:
     optfalse_check = Marty::SchemaHelper.required_if(['optfalse'],
                                                      opttf_is_false)
 
+    # optdisallow is not allowed if opttf is false
+    optdisallow_check = Marty::SchemaHelper.disallow_if_conds(['optdisallow'],
+                                                        opttf_is_false)
+
     # opttf is optional (contingent on req3) so eval of opttrue_check
     # and optfalse_check is dependent upon opttf existing
     opttruefalse_check = Marty::SchemaHelper.dep_check('opttf',
                                                     opttrue_check,
-                                                    optfalse_check)
+                                                    optfalse_check,
+                                                    optdisallow_check)
+
+    dip_check = Marty::SchemaHelper.disallow_if_present('opttf',
+                                                        'opt3', 'opt4')
+
+    dinp_check = Marty::SchemaHelper.disallow_if_not_present('opttf',
+                                                        'opt5', 'opt6')
 
     v1 = { "properties": properties,
            "required": ["req1", "req2", "req3"],
@@ -302,7 +314,9 @@ A:
                      opt1_check,
                      optn_check,
                      opttf_check,
-                     opttruefalse_check
+                     opttruefalse_check,
+                     dip_check,
+                     dinp_check
              ] }
 eof
 
@@ -1126,6 +1140,12 @@ describe Marty::RpcController do
       params = optionals.merge({"req1" => req1,
                                 "req2"=> req2,
                                 "req3"=> req3}).to_json
+
+      # to see what the schema helpers generated:
+      # engine = Marty::ScriptSet.new(nil).get_engine("M10Schemas")
+      # x=engine.evaluate("A", ["v1"],  {})
+      # binding.pry
+
       get 'evaluate', {
             format: :json,
             script: "M10",
@@ -1133,18 +1153,21 @@ describe Marty::RpcController do
             attrs: attrs,
             params: params
           }
+
     end
 
     it "does conditional" do
       aggregate_failures "conditionals" do
-        [# first group has all required fields
+        [
+          # first group has all required fields
           [['opt1', 'no opts', 'no opts', opt1: 'hi mom'], "hi mom"],
           [['no opts', 'no opts', 'no opts', opt1: 'hi mom'], "no opts"],
           [['opt2', 'opt2', 'no opts', optn: 'foo'], 'foo'],
           [['opt2', 'no opts', 'opt2'], 'req3'],
           [['opt2', 'no opts', 'opttf', opttf: true, opttrue: 'bar'], 'bar'],
           [['opt2', 'no opts', 'opttf', opttf: false, optfalse: 'baz'], 'baz'],
-          # second group is missing fields
+
+          # second group is missing fields or has other errors
           [['opt1', 'no opts', 'no opts'],
            "did not contain a required property of 'opt1'"],
           [['opt2', 'opt2', 'no opts',],
@@ -1155,11 +1178,23 @@ describe Marty::RpcController do
            "did not contain a required property of 'opttrue'"],
           [['opt2', 'no opts', 'opttf', opttf: false],
            "did not contain a required property of 'optfalse'"],
+          [['opt2', 'no opts', 'opttf', opttf: false, optfalse: "val",
+            optdisallow: "hi mom"],
+           "disallowed parameter 'optdisallow' of type string was received"],
+          [['opt2', 'no opts', 'opttf', opttf: false, optfalse: "val",
+            opt3: "hi"],
+           "disallowed parameter 'opt3' of type string was received"],
+          [['opt2', 'no opts', 'opttf', opttf: true, opttrue: "val",
+            opt4: "mom"],
+           "disallowed parameter 'opt4' of type string was received"],
+          [['opt2', 'no opts', 'xyz', opt5: "hi"],
+           "disallowed parameter 'opt5' of type string was received"],
         ].each do
           |a, exp|
           do_call(*a)
           res_hash = JSON.parse(response.body)
           got = res_hash.is_a?(Array) ? res_hash[0] : res_hash["error"]
+
           expect(got).to include(exp)
         end
       end

data/spec/lib/logger_spec.rb

@@ -10,6 +10,7 @@ module Marty
       Marty::Log.delete_all
     end
     after(:all) do
+      Marty::Log.delete_all
       self.use_transactional_fixtures = true
     end
 

data/spec/models/data_grid_spec.rb

@@ -718,7 +718,6 @@ EOS
 
         res = dgc.lookup_grid_distinct_entry('2/2/2014',
                                              {"property_state" => "CA"})
-
         expect(res["result"]).to eq(70)
 
         res = dgc.lookup_grid_distinct_entry('2/2/2015',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.0.44
+  version: 1.0.46
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-11 00:00:00.000000000 Z
+date: 2017-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -440,10 +440,13 @@ files:
 - app/models/marty/user_role.rb
 - app/views/layouts/marty/application.html.erb
 - app/views/layouts/marty/diagnostic.html.erb
-- app/views/marty/diagnostic/diagnostic.html.erb
+- app/views/marty/diagnostic/op.html.erb
 - config/database.yml.travis
 - config/locales/en.yml
 - config/routes.rb
+- db/js/errinfo_v1.js
+- db/js/lookup_grid_distinct_v1.js
+- db/js/query_grid_dir_v1.js
 - db/migrate/001_create_marty_scripts.rb
 - db/migrate/003_create_marty_users.rb
 - db/migrate/004_create_marty_roles.rb
@@ -478,6 +481,7 @@ files:
 - db/migrate/301_create_marty_api_log.rb
 - db/migrate/302_add_api_configs_validate_result.rb
 - db/migrate/303_create_marty_logs.rb
+- db/migrate/400_create_dg_plv8_v1_fns.rb
 - db/seeds.rb
 - delorean/script_report.dl
 - gemini_deprecations.md
@@ -585,7 +589,7 @@ files:
 - spec/dummy/lib/assets/.gitkeep
 - spec/dummy/lib/class_list.rb
 - spec/dummy/log/.gitkeep
-- spec/dummy/public/404.html
+- spec/dummy/public/400.html
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/favicon.ico