반응형
SMALL
프록시(Proxy)
프록시 패턴은 일반적으로 개체의 특성을 숨기기 위해 개체를 감쌉니다. 이러한 특성은 원격 개체(원격 프록시), 매우 큰 이미지 또는 테라바이트 데이터베이스 덤프(가상 프록시)와 같은 매우 무거운 개체 또는 제한된 액세스 개체(보호 프록시)일 수 있습니다.
package proxy
import "fmt"
type User struct {
ID int32
}
type UserList []User
func (t *UserList) FindUser(id int32) (User, error) {
for i := 0; i < len(*t); i++ {
if (*t)[i].ID == id {
return (*t)[i], nil
}
}
return User{}, fmt.Errorf("user %d could not be found", id)
}
type UserFinder interface {
FindUser(id int32) (User, error)
}
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 {
return User{}, err
}
u.addUserToStack(user)
fmt.Println("Returning user from database")
u.DidLastSearchUsedCache = false
return user, nil
}
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 (t *UserList) addUser(newUser User) {
*t = append(*t, newUser)
}위의 코드에 대한 Test Code
package proxy
import (
"math/rand"
"testing"
)
func Test_UserListProxy(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 doesn't 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 from an empty cache")
}
})
t.Run("FindUser - One user, ask for the same user", 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 doesn't match with expected")
}
if len(proxy.StackCache) != 1 {
t.Error("Cache must not grow if we asked for an object that is stored on it")
}
if !proxy.DidLastSearchUsedCache {
t.Error("The user should have been returned from the cache")
}
})
user1, err := proxy.FindUser(knownIDs[0])
if err != nil {
t.Fatal(err)
}
user2, _ := proxy.FindUser(knownIDs[1])
if proxy.DidLastSearchUsedCache {
t.Error("The user wasn't stored on the proxy cache yet")
}
user3, _ := proxy.FindUser(knownIDs[2])
if proxy.DidLastSearchUsedCache {
t.Error("The user wasn't stored on the proxy cache yet")
}
for i := 0; i < len(proxy.StackCache); i++ {
if proxy.StackCache[i].ID == user1.ID {
t.Error("User that should be gone was found")
}
}
if len(proxy.StackCache) != 2 {
t.Error("After inserting 3 users the cache should not grow" +
" more than to two")
}
for _, v := range proxy.StackCache {
if v != user2 && v != user3 {
t.Error("A non expected user was found on the cache")
}
}
}데코레이터(Decorator)
데코레이터 디자인 패턴을 사용하면 기존 유형을 실제로 만지지 않고 더 기능적인 기능으로 장식할 수 있습니다.
package decorator
import (
"errors"
"fmt"
)
type IngredientAdd interface {
AddIngredient() (string, error)
}
type PizzaDecorator struct {
Ingredient IngredientAdd
}
func (p *PizzaDecorator) AddIngredient() (string, error) {
return "Pizza with the following ingredients:", nil
}
type Meat struct {
Ingredient IngredientAdd
}
func (m *Meat) AddIngredient() (string, error) {
if m.Ingredient == nil {
return "", errors.New("an IngredientAdd is needed in the Ingredient field of the Meat")
}
s, err := m.Ingredient.AddIngredient()
if err != nil {
return "", err
}
return fmt.Sprintf("%s %s,", s, "meat"), nil
}
type Onion struct {
Ingredient IngredientAdd
}
func (o *Onion) AddIngredient() (string, error) {
if o.Ingredient == nil {
return "", errors.New("an IngredientAdd is needed in the Ingredient field of the Onion")
}
s, err := o.Ingredient.AddIngredient()
if err != nil {
return "", err
}
return fmt.Sprintf("%s %s,", s, "onion"), nil
}Test Code
package decorator
import (
"strings"
"testing"
)
func TestPizzaDecorator_AddIngredient(t *testing.T) {
pizza := &PizzaDecorator{}
pizzaResult, _ := pizza.AddIngredient()
expectedText := "Pizza with the following ingredients:"
if !strings.Contains(pizzaResult, expectedText) {
t.Errorf("When calling the add ingredient of the pizza decorator it must return the text %sthe expected text, not '%s'", pizzaResult, expectedText)
}
}
func TestOnion_AddIngredient(t *testing.T) {
onion := &Onion{}
onionResult, err := onion.AddIngredient()
if err == nil {
t.Errorf("When calling AddIngredient on the onion decorator without"+
"an IngredientAdd on its Ingredient field must return an error, not a string with '%s'", onionResult)
}
onion = &Onion{&PizzaDecorator{}}
onionResult, err = onion.AddIngredient()
if err != nil {
t.Error(err)
}
if !strings.Contains(onionResult, "onion") {
t.Errorf("When calling the add ingredient of the onion decorator it"+
"must return a text with the word 'onion', not '%s'", onionResult)
}
}
func TestMeat_AddIngredient(t *testing.T) {
meat := &Meat{}
meatResult, err := meat.AddIngredient()
if err == nil {
t.Errorf("When calling AddIngredient on the meat decorator without"+
"an IngredientAdd in its Ingredient field must return an error,"+
"not a string with '%s'", meatResult)
}
meat = &Meat{&PizzaDecorator{}}
meatResult, err = meat.AddIngredient()
if err != nil {
t.Error(err)
}
if !strings.Contains(meatResult, "meat") {
t.Errorf("When calling the add ingredient of the meat decorator it"+
"must return a text with the word 'meat', not '%s'", meatResult)
}
}
func TestPizzaDecorator_FullStack(t *testing.T) {
pizza := &Onion{&Meat{&PizzaDecorator{}}}
pizzaResult, err := pizza.AddIngredient()
if err != nil {
t.Error(err)
}
expectedText := "Pizza with the following ingredients: meat, onion"
if !strings.Contains(pizzaResult, expectedText) {
t.Errorf("When asking for a pizza with onion and meat the returned "+
"string must contain the text '%s' but '%s' didn't have it",
expectedText, pizzaResult)
}
t.Log(pizzaResult)
}퍼사드(Facade)
파사드는 건축 용어로 건물의 방과 복도를 가리는 전면 벽을 의미하고, 주민들을 추위와 비로부터 보호하고 그들에게 사생활을 제공합니다.
파사드 디자인 패턴도 이와 마찬가지로 원하지 않는 액세스로부터 코드를 보호하고, 일부 통화를 주문하며, 사용자로부터 복잡성 범위를 숨깁니다.
package facade
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
)
type CurrentWeatherDataRetriever interface {
GetByCityAndCountryCode(city, countryCode string) (Weather, error)
GetByGeoCoordinates(lat, lon float32) (Weather, error)
}
type Weather struct {
ID int `json:"id"`
Name string `json:"name"`
Cod int `json:"cod"`
Coord struct {
Lon float32 `json:"lon"`
Lat float32 `json:"lat"`
} `json:"coord"`
Weather []struct {
Id int `json:"id"`
Main string `json:"main"`
Description string `json:"description"`
Icon string `json:"icon"`
} `json:"weather"`
Base string `json:"base"`
Main struct {
Temp float32 `json:"temp"`
Pressure float32 `json:"pressure"`
Humidity float32 `json:"humidity"`
TempMin float32 `json:"temp_min"`
TempMax float32 `json:"temp_max"`
} `json:"main"`
Wind struct {
Speed float32 `json:"speed"`
Deg float32 `json:"deg"`
} `json:"wind"`
Clouds struct {
All int `json:"all"`
} `json:"clouds"`
Rain struct {
ThreeHours float32 `json:"3h"`
} `json:"rain"`
Dt uint32 `json:"dt"`
Sys struct {
Type int `json:"type"`
ID int `json:"id"`
Message float32 `json:"message"`
Country string `json:"country"`
Sunrise int `json:"sunrise"`
Sunset int `json:"sunset"`
} `json:"sys"`
}
type CurrentWeatherData struct {
APIkey string
}
func (c *CurrentWeatherData) responseParser(body io.Reader) (*Weather, error) {
w := new(Weather)
err := json.NewDecoder(body).Decode(w)
if err != nil {
return nil, err
}
return w, nil
}
func (c *CurrentWeatherData) GetByGeoCoordinates(lat, lon float32) (weather *Weather, err error) {
return c.doRequest(
fmt.Sprintf("http://api.openweathermap.org/data/2.5/weatherq=%f,%f&APPID=%s", lat, lon, c.APIkey))
}
func (c *CurrentWeatherData) GetByCityAndCountryCode(city, countryCode string) (weather *Weather, err error) {
return c.doRequest(
fmt.Sprintf("http://api.openweathermap.org/data/2.5/weather?lat=%s&lon=%s&APPID=%s", city, countryCode, c.APIkey))
}
func (c *CurrentWeatherData) doRequest(uri string) (weather *Weather, err error) {
client := &http.Client{}
req, err := http.NewRequest("GET", uri, nil)
if err != nil {
return
}
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
return
}
if resp.StatusCode != 200 {
byt, errMsg := ioutil.ReadAll(resp.Body)
if errMsg == nil {
errMsg = fmt.Errorf("%s", string(byt))
}
err = fmt.Errorf("status code was %d, aborting. Error message was:%s", resp.StatusCode, errMsg)
return
}
weather, err = c.responseParser(resp.Body)
resp.Body.Close()
return
}
func getMockData() io.Reader {
response := `{"coord":{"lon":-3.7,"lat":40.42},"weather":[{"id":803,"main":"Clouds","description":"broken clouds","icon":"04n"}],"base":"stations","main":{"temp":303.56,"pressure":1016.46,"humidity":26.8,"temp_min":300.95,"temp_max":305.93},"wind":{"speed":3.17,"deg":151.001},"rain":{"3h":0.0075},"clouds":{"all":68},"dt":1471295823,"sys":{"type":3,"id":1442829648,"message":0.0278,"country":"ES","sunrise":1471238808,"sunset":1471288232},"id":3117735,"name":"Madrid","cod":200}`
r := bytes.NewReader([]byte(response))
return r
}
Test Code
package facade
import "testing"
func TestOpenWeatherMap_responseParser(t *testing.T) {
r := getMockData()
openWeatherMap := CurrentWeatherData{APIkey: ""}
weather, err := openWeatherMap.responseParser(r)
if err != nil {
t.Fatal(err)
}
if weather.ID != 3117735 {
t.Errorf("Madrid id is 3117735, not %d", weather.ID)
}
}반응형
LIST