Added real prefs.

ngcp/ngcp.lua

@@ -50,15 +50,38 @@ NGCP_MT = { __index = NGCP }
         t.prefs = {
             domain = NGCPDomainPrefs:new(t.config),
             user   = NGCPUserPrefs:new(t.config),
-            peer   = NGCPPeerPrefs:new(t.config)
+            peer   = NGCPPeerPrefs:new(t.config),
+            real   = NGCPPeerPrefs:new(),
         }
         return t
     end
 
-    function NGCP:caller_load(uuid)
+    function NGCP:caller_load(uuid, domain, peer)
+        local keys = {
+            domain = self.prefs.domain:caller_load(domain),
+            user   = self.prefs.user:caller_load(uuid),
+            peer   = self.prefs.peer:caller_load(peer)
+        }
+        local unique_keys = table.deepcopy(keys.domain)
+        local _,v
+        for _,v in pairs(keys.user) do
+            table.add(unique_keys, v)
+        end
+        self.prefs.real:caller_load(unique_keys)
     end
 
-    function NGCP:callee_load(uuid)
+    function NGCP:callee_load(uuid, domain, peer)
+        local keys = {
+            domain = self.prefs.domain:callee_load(domain),
+            user   = self.prefs.user:callee_load(uuid),
+            peer   = self.prefs.peer:caller_load(peer)
+        }
+        local unique_keys = table.deepcopy(keys.domain)
+        local _,v
+        for _,v in pairs(keys.user) do
+            table.add(unique_keys, v)
+        end
+        self.prefs.real:callee_load(unique_keys)
     end
 -- class
 --EOF

ngcp/pp.lua

@@ -43,10 +43,8 @@ NGCPPeerPrefs_MT = { __index = NGCPPeerPrefs }
         con:close()
     end
 
-    function NGCPPeerPrefs:clean(...)
+    function NGCPPeerPrefs:clean()
-        if self.xavp then
+        sr.pv.unset("$xavp(peer)")
-            self.xavp:clean()
-        end
     end
 -- class
 --EOF

ngcp/rp.lua

@@ -0,0 +1,51 @@
+#!/usr/bin/env lua5.1
+require 'ngcp.xavp'
+
+-- class NGCPRealPrefs
+NGCPRealPrefs = {
+     __class__ = 'NGCPRealPrefs'
+ }
+NGCPRealPrefs_MT = { __index = NGCPRealPrefs }
+
+    function NGCPRealPrefs:new()
+        local t = {}
+        return setmetatable( t, NGCPRealPrefs_MT )
+    end
+
+    function NGCPRealPrefs:caller_load(keys)
+        return NGCPRealPrefs:_load("caller", keys)
+    end
+
+    function NGCPRealPrefs:callee_load(keys)
+        return NGCPRealPrefs:_load("callee", keys)
+    end
+
+    function NGCPRealPrefs:_load(level, keys)
+        local _,v
+        local xavp = {
+            real   = NGCPXAvp:new(level,'real', {}),
+            domain = NGCPXAvp:new(level,'domain', {}),
+            user   = NGCPXAvp:new(level,'user', {}),
+        }
+        local real_keys = {}
+        local value
+        for _,v in pairs(keys) do
+            value = xavp.user(v)
+            if not value then
+                value = xavp.domain(v)
+            end
+            if value then
+                table.add(real_keys, v)
+                xavp.real(v, value)
+            else
+                sr.log("err", string.format("key:%s not in user or domain", v))
+            end
+        end
+        return real_keys
+    end
+
+    function NGCPRealPrefs:clean()
+        sr.pv.unset("$xavp(real)")
+    end
+-- class
+--EOF

tests/ngcp.lua

@@ -49,22 +49,9 @@ TestNGCP = {} --class
         assertTrue(self.ngcp.prefs.peer)
         assertTrue(self.ngcp.prefs.user)
         assertTrue(self.ngcp.prefs.domain)
+        assertTrue(self.ngcp.prefs.real)
     end
 
-    function TestNGCP:test_peerpref_clean()
-        assertTrue(self.ngcp.prefs.peer)
-        self.ngcp.prefs.peer:clean()
-    end
-
-    function TestNGCP:test_userpref_clean()
-        assertTrue(self.ngcp.prefs.user)
-        self.ngcp.prefs.user:clean()
-    end
-
-    function TestNGCP:test_domainpref_clean()
-        assertTrue(self.ngcp.prefs.peer)
-        self.ngcp.prefs.peer:clean()
-    end
 -- class TestNGCP
 
 ---- Control test output:

tests/ngcp_rp.lua

@@ -0,0 +1,124 @@
+#!/usr/bin/env lua5.1
+require('luaunit')
+require 'ngcp.utils'
+require 'ngcp.rp'
+require 'tests_v.dp_vars'
+require 'tests_v.up_vars'
+
+if not sr then
+    require 'mocks.sr'
+    sr = srMock:new()
+else
+    require 'lemock'
+    argv = {}
+end
+local mc = nil
+
+PFetch = {
+    __class__ = 'PFetch',
+    _i = { domain=1, user=1 },
+    _var = { domain=dp_vars, user=up_vars}
+}
+    function PFetch:new()
+        local t = {}
+        return setmetatable(t, { __index = PFetch })
+    end
+
+    function PFetch:val(group, uuid)
+        if not self._i[group] then
+            error(string.format("group:%s unknown", group))
+        end
+        self._i[group] = self._i[group] + 1
+        local temp = self._var[group][uuid][self._i[group]-1]
+        if not temp then
+            print("var nil")
+        end
+    end
+
+    function PFetch:reset(group)
+        self._i[group] = 1
+    end
+
+TestNGCPRealPrefs = {} --class
+
+    function TestNGCPRealPrefs:setUp()
+        self.real = NGCPRealPrefs:new()
+    end
+
+    function TestNGCPRealPrefs:tearDown()
+        sr.pv.vars = {}
+    end
+
+    function TestNGCPRealPrefs:test_caller_load()
+        local keys = {"uno"}
+        local xavp = {
+            domain  = NGCPXAvp:new("caller", "domain", {}),
+            user    = NGCPXAvp:new("caller", "user", {}),
+            real    = NGCPXAvp:new("caller", "real", {})
+        }
+        xavp.domain("uno",1)
+        assertEquals(sr.pv.get("$xavp(domain[0]=>uno)"),1)
+        xavp.user("uno",2)
+        assertEquals(sr.pv.get("$xavp(user[0]=>uno)"),2)
+        local real_keys = self.real:caller_load(keys)
+        assertEquals(real_keys, keys)
+        assertEquals(xavp.real("uno"),2)
+    end
+
+    function TestNGCPRealPrefs:test_caller_load1()
+        local keys = {"uno", "dos"}
+        local xavp = {
+            domain  = NGCPXAvp:new("caller", "domain", {}),
+            user    = NGCPXAvp:new("caller", "user", {}),
+            real    = NGCPXAvp:new("caller", "real", {})
+        }
+        xavp.domain("uno",1)
+        assertEquals(sr.pv.get("$xavp(domain[0]=>uno)"),1)
+        xavp.user("dos",2)
+        assertEquals(sr.pv.get("$xavp(user[0]=>dos)"),2)
+        local real_keys = self.real:caller_load(keys)
+        assertEquals(real_keys, keys)
+        assertEquals(xavp.real("uno"),1)
+        assertEquals(xavp.real("dos"),2)
+    end
+
+    function TestNGCPRealPrefs:test_callee_load()
+        local keys = {"uno"}
+        local xavp = {
+            domain  = NGCPXAvp:new("callee", "domain", {}),
+            user    = NGCPXAvp:new("callee", "user", {}),
+            real    = NGCPXAvp:new("callee", "real", {})
+        }
+        xavp.domain("uno",1)
+        assertEquals(sr.pv.get("$xavp(domain[1]=>uno)"),1)
+        xavp.user("uno",2)
+        assertEquals(sr.pv.get("$xavp(user[1]=>uno)"),2)
+        local real_keys = self.real:callee_load(keys)
+        assertEquals(real_keys, keys)
+        assertEquals(xavp.real("uno"),2)
+    end
+
+    function TestNGCPRealPrefs:test_callee_load1()
+        local keys = {"uno", "dos"}
+        local xavp = {
+            domain  = NGCPXAvp:new("callee", "domain", {}),
+            user    = NGCPXAvp:new("callee", "user", {}),
+            real    = NGCPXAvp:new("callee", "real", {})
+        }
+        xavp.domain("uno",1)
+        assertEquals(sr.pv.get("$xavp(domain[1]=>uno)"),1)
+        xavp.user("dos",2)
+        assertEquals(sr.pv.get("$xavp(user[1]=>dos)"),2)
+        local real_keys = self.real:callee_load(keys)
+        assertEquals(real_keys, keys)
+        assertEquals(xavp.real("uno"),1)
+        assertEquals(xavp.real("dos"),2)
+    end
+-- class TestNGCPRealPrefs
+
+---- Control test output:
+lu = LuaUnit
+lu:setOutputType( "TAP" )
+lu:setVerbosity( 1 )
+lu:run()
+--EOF