add structural proxy pattern

Author: sensorario

README.md

@@ -15,3 +15,4 @@
  * [Binary Tree compositions](structural/binary-tree-compositions) [:notebook:](https://en.wikipedia.org/wiki/Binary_tree)
  * [Adapter](structural/adapter) [:notebook:](https://en.wikipedia.org/wiki/Adapter_pattern)
  * [Bridge](structural/bridge) [:notebook:](https://en.wikipedia.org/wiki/Bridge_pattern)
+ * [Proxy](structural/proxy) [:notebook:](https://it.wikipedia.org/wiki/Proxy_pattern)

structural/proxy/README.md

@@ -0,0 +1,61 @@
+# Proxy
+
+The design pattern usually wraps an object to hide some of its characteristics. The objectives of this patterns are ti hide an object behind the proxy so the features can be hidden, restricted and so on. Again, it provide a new abstraction layer that is easy to work with, and can be changed easily.
+
+In this example we have a database of users.
+
+```go
+type User struct {
+	ID int32
+}
+
+type UserList []User
+
+type UserFinder interface {
+	FindUser(id int32) (User, error)
+}
+```
+
+We dont use a slice of users because declaring a sequence of structs in this way it possibile to implement the interface UserFinder. A slice cant implement an interface.
+
+And here our proxy. A proxy here contains the database and the cache as UserList. The capacity limit the size of cache. All access to the data will be asked to this proxy. The proxy will save in cache new records. When a record will be asked first will be checked the presence in cache, then in database.
+
+```go
+type UserListProxy struct {
+	SomeDatabase           UserList
+	StackCache             UserList
+	StackCapacity          int
+}
+```
+
+As we said before, we used UserList as sequence of User to implement UserFinder interface. This because our database and our stack are both sequence of user.
+
+```go
+func (u *UserListProxy) FindUser(ID int32) (User, error) {
+	user, err := u.StackCache.FindUser(ID)
+	if err == nil {
+		fmt.Println("Returning user from cache")
+		u.DidLastSearchUsedCache = true
+		return user, nil
+	}
+
+	user, err = u.SomeDatabase.FindUser(ID)
+	if err == nil {
+		fmt.Println("Returning user from database")
+		u.addUserToStack(user)
+		u.DidLastSearchUsedCache = false
+		return user, nil
+	}
+
+	return User{}, fmt.Errorf("User not found")
+}
+
+func (u *UserList) FindUser(id int32) (User, error) {
+	for i := 0; i < len(*u); i++ {
+		if (*u)[i].ID == id {
+			return (*u)[i], nil
+		}
+	}
+	return User{}, fmt.Errorf("User %s could not be found\n", id)
+}
+```

structural/proxy/proxy.go

@@ -0,0 +1,62 @@
+package proxy
+
+import (
+	"fmt"
+)
+
+type User struct {
+	ID int32
+}
+
+type UserFinder interface {
+	FindUser(id int32) (User, error)
+}
+
+type UserList []User
+
+type UserListProxy struct {
+	SomeDatabase           UserList
+	StackCache             UserList
+	StackCapacity          int
+	DidLastSearchUsedCache bool
+}
+
+func (u *UserListProxy) FindUser(ID int32) (User, error) {
+	user, err := u.StackCache.FindUser(ID)
+	if err == nil {
+		fmt.Println("Returning user from cache")
+		u.DidLastSearchUsedCache = true
+		return user, nil
+	}
+
+	user, err = u.SomeDatabase.FindUser(ID)
+	if err == nil {
+		fmt.Println("Returning user from database")
+		u.addUserToStack(user)
+		u.DidLastSearchUsedCache = false
+		return user, nil
+	}
+
+	return User{}, fmt.Errorf("User not found")
+}
+
+func (u *UserListProxy) addUserToStack(user User) {
+	if len(u.StackCache) >= u.StackCapacity {
+		u.StackCache = append(u.StackCache[1:], user)
+	} else {
+		u.StackCache.addUser(user)
+	}
+}
+
+func (u *UserList) addUser(newUser User) {
+	*u = append(*u, newUser)
+}
+
+func (u *UserList) FindUser(id int32) (User, error) {
+	for i := 0; i < len(*u); i++ {
+		if (*u)[i].ID == id {
+			return (*u)[i], nil
+		}
+	}
+	return User{}, fmt.Errorf("User %s could not be found\n", id)
+}

structural/proxy/proxy_test.go

@@ -0,0 +1,53 @@
+package proxy
+
+import (
+	"math/rand"
+	"testing"
+)
+
+func TestUserListProxy(t *testing.T) {
+	someDatabase := UserList{}
+	rand.Seed(2342342)
+	for i := 0; i < 1000000; i++ {
+		n := rand.Int31()
+		someDatabase = append(someDatabase, User{ID: n})
+	}
+
+	proxy := UserListProxy{
+		SomeDatabase:  someDatabase,
+		StackCapacity: 2,
+		StackCache:    UserList{},
+	}
+
+	knownIDs := [3]int32{
+		someDatabase[3].ID,
+		someDatabase[4].ID,
+		someDatabase[5].ID,
+	}
+
+	t.Run("FindUser = Empty cache", func(t *testing.T) {
+		user, err := proxy.FindUser(knownIDs[0])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if user.ID != knownIDs[0] {
+			t.Error("Returned user name doesnt match with expected")
+		}
+		if len(proxy.StackCache) != 1 {
+			t.Error("After one successful search in an empty cache, the size of it must be one")
+		}
+		if proxy.DidLastSearchUsedCache {
+			t.Error("No user can be returned frmo an emtpy cache")
+		}
+	})
+
+	t.Run("FindUser = One user ask for same user", func(t *testing.T) {
+		_, err := proxy.FindUser(knownIDs[0])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !proxy.DidLastSearchUsedCache {
+			t.Error("No user can be returned frmo an emtpy cache")
+		}
+	})
+}