Merge pull request #7 from systemli/Implement-Senders-Handler

✨ Implement Senders Handler

Author: 0x46616c6b

adapter.go

@@ -104,6 +104,35 @@ func (p *PostfixAdapter) MailboxHandler(conn net.Conn) {
 	_, _ = conn.Write([]byte("200 1\n"))
 }
 
+// SendersHandler handles the get command for senders.
+// It fetches the senders for the given email.
+// The response is a comma separated list of senders.
+func (p *PostfixAdapter) SendersHandler(conn net.Conn) {
+	defer conn.Close()
+
+	payload, err := p.payload(conn)
+	if err != nil {
+		fmt.Println("Error getting payload:", err.Error())
+		_, _ = conn.Write([]byte("400 Error getting payload\n"))
+		return
+	}
+
+	email := strings.TrimSuffix(payload, "\n")
+	senders, err := p.client.GetSenders(string(email))
+	if err != nil {
+		fmt.Println("Error fetching senders:", err.Error())
+		_, _ = conn.Write([]byte("400 Error fetching senders\n"))
+		return
+	}
+
+	if len(senders) == 0 {
+		_, _ = conn.Write([]byte("500 NO%20RESULT\n"))
+		return
+	}
+
+	_, _ = conn.Write([]byte(fmt.Sprintf("200 %s \n", strings.Join(senders, ","))))
+}
+
 // payload reads the data from the connection. It checks for valid
 // commands sent by postfix and returns the payload.
 func (h *PostfixAdapter) payload(conn net.Conn) (string, error) {

adapter_test.go

@@ -244,6 +244,95 @@ func (s *AdapterTestSuite) TestMailboxHandler() {
 	})
 }
 
+func (s *AdapterTestSuite) TestSendersHandler() {
+	userli := new(MockUserliService)
+	userli.On("GetSenders", "user@example.com").Return([]string{"user@example.com"}, nil)
+	userli.On("GetSenders", "alias@example.com").Return([]string{"user1@example.com", "user2@example.com"}, nil)
+	userli.On("GetSenders", "error@example.com").Return([]string{}, errors.New("error"))
+	userli.On("GetSenders", "nonexisting@example.com").Return([]string{}, nil)
+
+	portNumber, _ := rand.Int(rand.Reader, big.NewInt(65535-20000))
+	portNumber.Add(portNumber, big.NewInt(20000))
+	listen := ":" + portNumber.String()
+
+	adapter := NewPostfixAdapter(userli)
+
+	go StartTCPServer(s.ctx, s.wg, listen, adapter.SendersHandler)
+
+	// wait until the server is ready
+	for {
+		conn, err := net.Dial("tcp", listen)
+		if err == nil {
+			conn.Close()
+			break
+		}
+	}
+
+	s.Run("success", func() {
+		conn, err := net.Dial("tcp", listen)
+		s.NoError(err)
+
+		_, err = conn.Write([]byte("get user@example.com"))
+		s.NoError(err)
+
+		response := make([]byte, 4096)
+		_, err = conn.Read(response)
+		s.NoError(err)
+
+		s.Equal("200 user@example.com \n", string(bytes.Trim(response, "\x00")))
+
+		conn.Close()
+	})
+
+	s.Run("alias success", func() {
+		conn, err := net.Dial("tcp", listen)
+		s.NoError(err)
+
+		_, err = conn.Write([]byte("get alias@example.com"))
+		s.NoError(err)
+
+		response := make([]byte, 4096)
+		_, err = conn.Read(response)
+		s.NoError(err)
+
+		s.Equal("200 user1@example.com,user2@example.com \n", string(bytes.Trim(response, "\x00")))
+
+		conn.Close()
+	})
+
+	s.Run("error", func() {
+		conn, err := net.Dial("tcp", listen)
+		s.NoError(err)
+
+		_, err = conn.Write([]byte("get error@example.com"))
+		s.NoError(err)
+
+		response := make([]byte, 4096)
+		_, err = conn.Read(response)
+		s.NoError(err)
+
+		s.Equal("400 Error fetching senders\n", string(bytes.Trim(response, "\x00")))
+
+		conn.Close()
+	})
+
+	s.Run("empty result", func() {
+		conn, err := net.Dial("tcp", listen)
+		s.NoError(err)
+
+		_, err = conn.Write([]byte("get nonexisting@example.com"))
+		s.NoError(err)
+
+		response := make([]byte, 4096)
+		_, err = conn.Read(response)
+		s.NoError(err)
+
+		s.Equal("500 NO%20RESULT\n", string(bytes.Trim(response, "\x00")))
+
+		conn.Close()
+	})
+}
+
 func TestAdapterTestSuite(t *testing.T) {
 	suite.Run(t, new(AdapterTestSuite))
 }

main.go

@@ -42,6 +42,11 @@ func main() {
 		mailboxListenAddr = ":10003"
 	}
 
+	sendersListenAddr := os.Getenv("SENDERS_LISTEN_ADDR")
+	if sendersListenAddr == "" {
+		sendersListenAddr = ":10004"
+	}
+
 	userli := NewUserli(userliToken, userliBaseURL)
 	adapter := NewPostfixAdapter(userli)
 
@@ -50,10 +55,11 @@ func main() {
 
 	var wg sync.WaitGroup
 
-	wg.Add(3)
+	wg.Add(4)
 	go StartTCPServer(ctx, &wg, aliasListenAddr, adapter.AliasHandler)
 	go StartTCPServer(ctx, &wg, domainListenAddr, adapter.DomainHandler)
 	go StartTCPServer(ctx, &wg, mailboxListenAddr, adapter.MailboxHandler)
+	go StartTCPServer(ctx, &wg, sendersListenAddr, adapter.SendersHandler)
 
 	wg.Wait()
 	fmt.Println("Servers stopped")

mock_UserliService.go

@@ -11,6 +11,7 @@ type UserliService interface {
 	GetAliases(email string) ([]string, error)
 	GetDomain(domain string) (bool, error)
 	GetMailbox(email string) (bool, error)
+	GetSenders(email string) ([]string, error)
 }
 
 type Userli struct {
@@ -73,6 +74,21 @@ func (u *Userli) GetMailbox(email string) (bool, error) {
 	return result, nil
 }
 
+func (u *Userli) GetSenders(email string) ([]string, error) {
+	resp, err := u.call(fmt.Sprintf("%s/api/postfix/senders/%s", u.baseURL, email))
+	if err != nil {
+		return []string{}, err
+	}
+
+	var senders []string
+	err = json.NewDecoder(resp.Body).Decode(&senders)
+	if err != nil {
+		return []string{}, err
+	}
+
+	return senders, nil
+}
+
 func (u *Userli) call(url string) (*http.Response, error) {
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {

userli.go

@@ -153,6 +153,56 @@ func (s *UserliTestSuite) TestGetMailbox() {
 	})
 }
 
+func (s *UserliTestSuite) TestGetSenders() {
+	s.Run("success", func() {
+		gock.New("http://localhost:8000").
+			Get("/api/postfix/senders/user@example.com").
+			MatchHeader("Authentication", "Bearer insecure").
+			MatchHeader("Accept", "application/json").
+			MatchHeader("Content-Type", "application/json").
+			MatchHeader("User-Agent", "userli-postfix-adapter").
+			Reply(200).
+			JSON([]string{"user@example.com"})
+
+		senders, err := s.userli.GetSenders("user@example.com")
+		s.NoError(err)
+		s.Equal([]string{"user@example.com"}, senders)
+		s.True(gock.IsDone())
+	})
+
+	s.Run("alias success", func() {
+		gock.New("http://localhost:8000").
+			Get("/api/postfix/senders/alias@example.com").
+			MatchHeader("Authentication", "Bearer insecure").
+			MatchHeader("Accept", "application/json").
+			MatchHeader("Content-Type", "application/json").
+			MatchHeader("User-Agent", "userli-postfix-adapter").
+			Reply(200).
+			JSON([]string{"user1@example.com", "user2@example.com"})
+
+		senders, err := s.userli.GetSenders("alias@example.com")
+		s.NoError(err)
+		s.Equal([]string{"user1@example.com", "user2@example.com"}, senders)
+		s.True(gock.IsDone())
+	})
+
+	s.Run("error", func() {
+		gock.New("http://localhost:8000").
+			Get("/api/postfix/senders/user@example.com").
+			MatchHeader("Authentication", "Bearer insecure").
+			MatchHeader("Accept", "application/json").
+			MatchHeader("Content-Type", "application/json").
+			MatchHeader("User-Agent", "userli-postfix-adapter").
+			Reply(500).
+			JSON(map[string]string{"error": "internal server error"})
+
+		senders, err := s.userli.GetSenders("user@example.com")
+		s.Error(err)
+		s.Empty(senders)
+		s.True(gock.IsDone())
+	})
+}
+
 func TestUserl(t *testing.T) {
 	suite.Run(t, new(UserliTestSuite))
 }