Refactor ngx mock and indent using 2 spaces

rootfs/etc/nginx/lua/test/balancer/sticky_test.lua

@@ -2,148 +2,145 @@ local sticky = require("balancer.sticky")
 local cookie = require("resty.cookie")
 local util = require("util")
 
-function get_mocked_ngx_env()
+function mock_ngx(mock)
-    local _ngx = {
+  local _ngx = mock
-        var = {},
+  setmetatable(_ngx, {__index = _G.ngx})
-    }
+  _G.ngx = _ngx
-    setmetatable(_ngx, {__index = _G.ngx})
-    return _ngx
 end
 
 function get_mocked_cookie_new()
-    return function(self)
+  return function(self)
-        return {
+    return {
-            get = function(self, n) return nil, "error" end,
+      get = function(self, n) return nil, "error" end,
-            set = function(self, n) return true, "" end
+      set = function(self, n) return true, "" end
-        }
+    }
-    end
+  end
 end
 
-_G.ngx = get_mocked_ngx_env()
+mock_ngx({ var = {} })
 cookie.new = get_mocked_cookie_new()
 
 local function get_test_backend()
-    return {
+  return {
-        name = "access-router-production-web-80",
+    name = "access-router-production-web-80",
-        endpoints = {
+    endpoints = {
-            { address = "10.184.7.40", port = "8080", maxFails = 0, failTimeout = 0 },
+      { address = "10.184.7.40", port = "8080", maxFails = 0, failTimeout = 0 },
-        },
+    },
-        sessionAffinityConfig = {
+    sessionAffinityConfig = {
-            name = "cookie",
+      name = "cookie",
-            cookieSessionAffinity = { name = "test_name", hash = "sha1" }
+      cookieSessionAffinity = { name = "test_name", hash = "sha1" }
-        },
+    },
-    }
+  }
 end
 
 describe("Sticky", function()
-    local test_backend = get_test_backend()
+  local test_backend = get_test_backend()
-    local test_backend_endpoint= test_backend.endpoints[1].address .. ":" .. test_backend.endpoints[1].port
+  local test_backend_endpoint= test_backend.endpoints[1].address .. ":" .. test_backend.endpoints[1].port
 
-    describe("new(backend)", function()
+  describe("new(backend)", function()
-        context("when backend specifies cookie name", function()
+    context("when backend specifies cookie name", function()
-            it("should return an instance containing the corresponding cookie name", function()
+      it("returns an instance containing the corresponding cookie name", function()
-                local sticky_balancer_instance = sticky:new(test_backend)
+        local sticky_balancer_instance = sticky:new(test_backend)
-                local test_backend_cookie_name = test_backend.sessionAffinityConfig.cookieSessionAffinity.name
+        local test_backend_cookie_name = test_backend.sessionAffinityConfig.cookieSessionAffinity.name
-                assert.equal(sticky_balancer_instance.cookie_name, test_backend_cookie_name)
+        assert.equal(sticky_balancer_instance.cookie_name, test_backend_cookie_name)
-            end)
+      end)
-        end)
-
-        context("when backend does not specify cookie name", function()
-            it("should return an instance with 'route' as cookie name", function()
-                local temp_backend = util.deepcopy(test_backend)
-                temp_backend.sessionAffinityConfig.cookieSessionAffinity.name = nil
-                local sticky_balancer_instance = sticky:new(temp_backend)
-                local default_cookie_name = "route"
-                assert.equal(sticky_balancer_instance.cookie_name, default_cookie_name)
-            end)
-        end)
-        
-        context("when backend specifies hash function", function()
-            it("should return an instance with the corresponding hash implementation", function()
-                local sticky_balancer_instance = sticky:new(test_backend)
-                local test_backend_hash_fn = test_backend.sessionAffinityConfig.cookieSessionAffinity.hash
-                local test_backend_hash_implementation = util[test_backend_hash_fn .. "_digest"]
-                assert.equal(sticky_balancer_instance.digest_func, test_backend_hash_implementation)
-            end)
-        end)
-
-        context("when backend does not specify hash function", function()
-            it("should return an instance with the default implementation (md5)", function()
-                local temp_backend = util.deepcopy(test_backend)
-                temp_backend.sessionAffinityConfig.cookieSessionAffinity.hash = nil
-                local sticky_balancer_instance = sticky:new(temp_backend)
-                local default_hash_fn = "md5"
-                local default_hash_implementation = util[default_hash_fn .. "_digest"]
-                assert.equal(sticky_balancer_instance.digest_func, default_hash_implementation)
-            end)
-        end)
     end)
 
-    describe("balance()", function()
+    context("when backend does not specify cookie name", function()
-        local mocked_cookie_new = cookie.new
+      it("returns an instance with 'route' as cookie name", function()
-
+        local temp_backend = util.deepcopy(test_backend)
-        before_each(function()
+        temp_backend.sessionAffinityConfig.cookieSessionAffinity.name = nil
-            package.loaded["balancer.sticky"] = nil
+        local sticky_balancer_instance = sticky:new(temp_backend)
-            sticky = require("balancer.sticky")
+        local default_cookie_name = "route"
-        end)
+        assert.equal(sticky_balancer_instance.cookie_name, default_cookie_name)
-
+      end)
-        after_each(function()
-            cookie.new = mocked_cookie_new
-        end)
-
-        context("when client doesn't have a cookie set", function()
-            it("should pick an endpoint for the client", function()
-                local sticky_balancer_instance = sticky:new(test_backend)
-                local peer = sticky_balancer_instance:balance()
-                assert.equal(peer, test_backend_endpoint)
-            end)
-
-            it("should set a cookie on the client", function() 
-                local s = {}
-                cookie.new = function(self)
-                    local test_backend_hash_fn = test_backend.sessionAffinityConfig.cookieSessionAffinity.hash
-                    local cookie_instance = {
-                        set = function(self, payload)
-                            assert.equal(payload.key, test_backend.sessionAffinityConfig.cookieSessionAffinity.name)
-                            assert.equal(payload.value, util[test_backend_hash_fn .. "_digest"](test_backend_endpoint))
-                            assert.equal(payload.path, "/")
-                            assert.equal(payload.domain, nil)
-                            assert.equal(payload.httponly, true)
-                            return true, nil 
-                        end,
-                        get = function(k) return false end,
-                    }
-                    s = spy.on(cookie_instance, "set")
-                    return cookie_instance, false
-                end
-                local sticky_balancer_instance = sticky:new(get_test_backend())
-                assert.has_no.errors(function() sticky_balancer_instance:balance() end)
-                assert.spy(s).was_called()
-            end)
-        end)
-
-        context("when client has a cookie set", function()
-            it("should not set a cookie", function()
-                local s = {}
-                cookie.new = function(self) 
-                    local return_obj = {
-                        set = function(v) return false, nil end,
-                        get = function(k) return test_backend_endpoint end,
-                    }
-                    s = spy.on(return_obj, "set")
-                    return return_obj, false
-                end
-                local sticky_balancer_instance = sticky:new(test_backend)
-                assert.has_no.errors(function() sticky_balancer_instance:balance() end)
-                assert.spy(s).was_not_called()
-            end)
-
-            it("should return the correct endpoint for the client", function()
-                local sticky_balancer_instance = sticky:new(test_backend)
-                local peer = sticky_balancer_instance:balance()
-                assert.equal(peer, test_backend_endpoint)
-            end)
-        end)
     end)
+        
+    context("when backend specifies hash function", function()
+      it("returns an instance with the corresponding hash implementation", function()
+        local sticky_balancer_instance = sticky:new(test_backend)
+        local test_backend_hash_fn = test_backend.sessionAffinityConfig.cookieSessionAffinity.hash
+        local test_backend_hash_implementation = util[test_backend_hash_fn .. "_digest"]
+        assert.equal(sticky_balancer_instance.digest_func, test_backend_hash_implementation)
+      end)
+    end)
+
+    context("when backend does not specify hash function", function()
+      it("returns an instance with the default implementation (md5)", function()
+        local temp_backend = util.deepcopy(test_backend)
+        temp_backend.sessionAffinityConfig.cookieSessionAffinity.hash = nil
+        local sticky_balancer_instance = sticky:new(temp_backend)
+        local default_hash_fn = "md5"
+        local default_hash_implementation = util[default_hash_fn .. "_digest"]
+        assert.equal(sticky_balancer_instance.digest_func, default_hash_implementation)
+      end)
+    end)
+  end)
+
+  describe("balance()", function()
+    local mocked_cookie_new = cookie.new
+
+    before_each(function()
+      package.loaded["balancer.sticky"] = nil
+      sticky = require("balancer.sticky")
+    end)
+
+    after_each(function()
+      cookie.new = mocked_cookie_new
+    end)
+
+    context("when client doesn't have a cookie set", function()
+      it("picks an endpoint for the client", function()
+        local sticky_balancer_instance = sticky:new(test_backend)
+        local peer = sticky_balancer_instance:balance()
+        assert.equal(peer, test_backend_endpoint)
+      end)
+
+      it("sets a cookie on the client", function() 
+        local s = {}
+        cookie.new = function(self)
+          local test_backend_hash_fn = test_backend.sessionAffinityConfig.cookieSessionAffinity.hash
+          local cookie_instance = {
+            set = function(self, payload)
+              assert.equal(payload.key, test_backend.sessionAffinityConfig.cookieSessionAffinity.name)
+              assert.equal(payload.value, util[test_backend_hash_fn .. "_digest"](test_backend_endpoint))
+              assert.equal(payload.path, "/")
+              assert.equal(payload.domain, nil)
+              assert.equal(payload.httponly, true)
+              return true, nil 
+            end,
+            get = function(k) return false end,
+          }
+          s = spy.on(cookie_instance, "set")
+          return cookie_instance, false
+        end
+        local sticky_balancer_instance = sticky:new(get_test_backend())
+        assert.has_no.errors(function() sticky_balancer_instance:balance() end)
+        assert.spy(s).was_called()
+      end)
+    end)
+
+    context("when client has a cookie set", function()
+      it("does not set a cookie", function()
+        local s = {}
+        cookie.new = function(self) 
+          local return_obj = {
+            set = function(v) return false, nil end,
+            get = function(k) return test_backend_endpoint end,
+          }
+          s = spy.on(return_obj, "set")
+          return return_obj, false
+        end
+        local sticky_balancer_instance = sticky:new(test_backend)
+        assert.has_no.errors(function() sticky_balancer_instance:balance() end)
+        assert.spy(s).was_not_called()
+      end)
+
+      it("returns the correct endpoint for the client", function()
+        local sticky_balancer_instance = sticky:new(test_backend)
+        local peer = sticky_balancer_instance:balance()
+        assert.equal(peer, test_backend_endpoint)
+      end)
+    end)
+  end)
 end)
-